Forem: Idil Saglam

Building and Deploying a Real Web App for Cloud Phone (in 3 Minutes)

Idil Saglam — Sat, 10 May 2025 12:53:27 +0000

It’s 2025 and I just deployed a full app to a feature phone that has no touchscreen

It worked on the first try.

And it runs TikTok, Instagram, Facebook and now my own app.

Let’s talk about Cloud Phone.

What is Cloud Phone?

Cloud Phone is a feature phone platform powered by CloudMosa’s remote rendering engine: your app rendered in the cloud, streamed to a $20 phone that only has a key pad including arrows,and OK.

It runs full HTML5, CSS, JS.

No paid developer account.
No proprietary SDK or language.
No CPU heavy build system.

Just good old HTML, CSS and JS.
You can also use React, Svelte and Vue

As you build a regular web application.

My Use Case

I built an app called Color Stylist that:

Let users pick a base color
Shows matching combos using HSL logic (contrast, split, triadic)
Doesn’t need a touchscreen or pointer

Stack:

Vanilla HTML, CSS, JS
No frameworks
No dependencies
Optimized for QVGA (240×320)
Hosted on GitHub Pages

Dev flow

Here's the entire dev flow:

I created a web app, like a regular web app
Added arrow key handling:

document.addEventListener("keydown", (e) => {
  if (e.key === "ArrowRight") goToNextColor();
  if (e.key === "ArrowLeft") goToPrevColor();
});

Deployed it on GitHub Pages
Registered it at developer.cloudfone.com
Added my phone’s IMEI
Enabled Developer Mode

Done.

I didn’t install anything. Didn’t write a manifest. Didn’t deal with WebView bugs.

Why This Matters

Cloud Phone gives developers the power to ship real tools to real devices that are still actively used across the globe.

And it respects your time.

Feature	Supported
HTTPS-based deployment	✔️
Keyboard navigation (no touch)	✔️
Remote rendering (via cloud)	✔️
2G-compatible performance	✔️
Web standard support (HTML5 / ES2023)	✔️
Static site hosting	✔️

👋 Final Thoughts

This isn’t nostalgia, it’s practicality at scale.

If you want to scale your web app on a real web scale, not just for the hype,then you should absolutely build for Cloud Phone.

Full dev docs → developer.cloudfone.com

What the hack are CI/CD pipelines?

Idil Saglam — Thu, 19 Dec 2024 18:04:39 +0000

OK. First of all, you need to understand some fancy terms to know in order to understand properly what CI/CD pipelines are.

Good to know: CI/CD stands for Continuous Integration and Continuous Delivery/Deployment which are practices used in software development to automate and streamline the process of building, testing, and deploying applications.

Continuous Integration (CI)

Developers frequently push code to a shared repository (like GitHub or GitLab).Every time new code is added (through a commit or pull request), the CI pipeline runs automatically.

It usually:
- Builds the application (compiling the code).
- Runs tests to ensure the new code doesn’t break existing features.

If the build or tests fail, developers are notified, and they can fix the problem quickly.

So, to sum up the goal of Continuous Integration (CI) is
automate the process of integrating code changes into a shared codebase.

Real-life example:
Let’s say you’re working on a website. Every time you make a change and push it to the main repository, the CI pipeline will:

Automatically build your project (e.g., turn your code into an executable or deployable state).
Run a set of automated tests to check if your changes are working.
Report if something is broken so you can fix it immediately.

Continuous Delivery (CD)

Once the CI process finishes and the code is verified, the CD part of the pipeline ensures the code is ready to be deployed at any time.

Continuous Delivery means that the code is always in a deployable state, but human approval might be required to actually deploy it to production.

So, the goal of Continuous Delivery is to automate the deployment of applications to different environments (like staging, testing, and production).

Continuous Deployment (CD):

This takes Continuous Delivery a step further by automatically deploying every code change that passes tests directly to production without human intervention.

This is useful for fast-moving projects that need frequent updates, but it requires a very mature pipeline.

How Does a CI/CD Pipeline Look?

Developer commits code.
CI pipeline starts:
- Builds the application.
- Runs unit tests.
If successful, the CD pipeline starts:
- Deploys to a staging or testing environment for further checks.
If everything looks good:
- Either deploys to production automatically (Continuous Deployment) or waits for manual approval to deploy (Continuous Delivery).

Key Tools for CI/CD:

Jenkins, GitLab CI, GitHub Actions, CircleCI – Automate the CI/CD process.
Docker, Kubernetes – Often used for deploying applications in containers.

In summary, CI/CD helps developers work more efficiently by automating routine tasks like testing and deploying, so they can focus on writing code and delivering features faster.

Happy coding!

Graph Databases Are So Cool, Use neo4j

Idil Saglam — Mon, 21 Oct 2024 12:40:58 +0000

I’ve always been fascinated by graphs. In my computer science classes, my favorite subjects were the ones focused on graphs and automata. I loved how we could use graph structures to represent all kinds of connections—whether it was mapping out states in automata or understanding network flow. It was exciting to see how efficiently graphs could model real-world problems.

That interest in graph theory naturally translated to my appreciation for graph databases like Neo4j. Just like those graph structures we used in class, Neo4j allows you to represent data in a way that highlights relationships and connections. Instead of trying to fit everything into rows and columns, like in traditional relational databases, Neo4j lets you use nodes and edges to represent data. This approach is perfect for real-world applications where relationships between data points matter most. Whether you're analyzing social networks, managing complex supply chains, or building recommendation systems, graph databases can make a huge difference by simplifying the way relationships are stored and queried.

Why Graph Databases?

Traditional databases, like relational databases, are great for structured data, but they struggle when managing complex relationships between different entities.

Neo4j is a graph database explicitly designed to deal with these kinds of problems. Instead of using tables and foreign keys like in relational databases, Neo4j uses nodes (think: people, products, places) and relationships (how those nodes are connected). This makes querying those connections super fast and efficient.

Why use neo4j?

Traditional relational databases struggle when you need to manage complex relationships. For example, if you're trying to find connections between entities, like "friends of friends," relational databases require expensive joins between tables, which get slow as the data grows. In Neo4j, there’s no need for these joins. You can directly traverse nodes and relationships, making queries that involve connections much faster and more efficient.

Another advantage of Neo4j is its flexibility. In traditional databases, making changes to the schema—like adding new columns or relationships—can break things or require major adjustments. Neo4j is much more adaptable. You can easily introduce new types of data or relationships without overhauling the entire structure. This makes it ideal for real-world applications, where the data model frequently evolves over time.

If your app needs to grow and adapt quickly, Neo4j is ready to handle those changes without the usual headaches.

Neo4j is also great at managing complex queries. If you need to explore deep relationships, such as finding patterns in connected data or discovering how entities relate across multiple layers, Neo4j is designed for this. Traditional databases can struggle with such queries, making them slow and difficult to manage. Neo4j, on the other hand, is optimized for traversing these relationships efficiently, ensuring that even with large datasets, your queries perform well and return results quickly.

Neo4j comes packed with powerful built-in graph algorithms that make analyzing complex relationships easier. For example, the Shortest Path algorithm lets you quickly find the most direct connection between two nodes, such as discovering how two people are linked in a social network. Neo4j also offers Community Detection, which helps you find clusters of related nodes—perfect for social network analysis or detecting groups in your data. Additionally, PageRank can measure the importance of nodes, much like how Google ranks web pages based on their relevance and connections. These algorithms allow you to run deep analysis on your data without needing to reinvent the wheel.

When Should You Use Neo4j?

Neo4j is the go-to choice whenever your application is heavily relationship-based. If you're building something like a social network, recommendation system, or even a fraud detection tool, where understanding the connections between people or entities is critical, Neo4j’s graph structure is far more efficient than traditional databases. It’s also ideal when you need to run advanced analyses on your data, such as finding connections, identifying key influencers, or uncovering patterns within complex networks. Simply put, if your data revolves around relationships, Neo4j is built to handle it.

Neo4j is revolutionizing data modeling by focusing on relationships first. It handles complex queries more efficiently, offers flexibility in data modeling, and is packed with built-in graph algorithms that make solving real-world problems easier. If your app deals with a lot of connections, Neo4j might be exactly what you need to make life simpler.

Happy coding!

Understand Kubernetes Without the Headaches

Idil Saglam — Wed, 02 Oct 2024 11:21:26 +0000

Kubernetes (K8s) is a tool for managing containers. It is useful when you have many containers and want to manage them smartly and automatically.

Why do we need Kubernetes?

Let's say you've built a shopping website. When you first launch it, you might have a small number of users, so your app is only running on one server, and it works fine.

Now, let's say it's Black Friday, and thousands of people are visiting your site simultaneously to shop. One server won't be able to handle that much traffic. Your website might slow down or even crash because the server is overloaded.

If you use Kubernetes, you can add more servers and run multiple copies of your app on those servers. This will spread the traffic across all the servers so that no single server gets too much traffic. So, even when lots of people are using your website, it will keep things running smoothly.

When traffic returns to normal, Kubernetes can reduce the number of servers to save resources and costs.

So, you'd need Kubernetes to ensure that your app can handle sudden spikes in traffic and keep running without problems, especially during sales events, product launches, or whenever you expect more users than usual.

Plus: When you need to update your app, Kubernetes does it gradually (rolling updates), so your app keeps running without downtime.

Fancy Kubernetes that you need to understand

Cluster:

Clusters are a group of machines (can be physical or virtual) that work together.These machines can be located in the cloud, in your data center, or on your computer.

A cluster is made up of:

Master node: The brain of Kubernetes, which manages everything.
Worker nodes: The machines where your app containers run.

Pods

A Pod is the smallest part of Kubernetes. It's where your app's containers run. If you want to run your app, Kubernetes places it inside a Pod. If you need more than one copy of your app running (for example, to handle more users), Kubernetes creates multiple Pods, each running a copy of your app.

Example: If you want to run 5 copies of your app, Kubernetes will create 5 Pods, each one running your app inside a container.

Deployment

A Deployment is a way to tell Kubernetes how many copies of your app you want running. For example, if you say, "I need 3 copies of my app running at all times," Kubernetes will make sure 3 Pods are running.

If one Pod crashes or stops working, Kubernetes will automatically create a new one to keep 3 Pods running at all times.

Service

A Service in Kubernetes helps you expose your app to the outside world (like the internet) or connect different parts of your app internally. It gives your app a fixed address, so even if the Pods running your app are restarted or moved to another machine, your app is still accessible at the same address.

Scaling

When more people start using your app and the traffic increases, you might need more copies of your app to handle the load. Kubernetes can automatically scale your app by starting more Pods. Likewise, if traffic decreases, Kubernetes can stop some of the Pods to save resources.

A simple workflow with Kubernetes

You write your app and package it in a Docker container.
You create a Kubernetes deployment to tell Kubernetes how many copies (Pods) of your app to run.
Kubernetes takes care of the rest: It starts the specified number of Pods, monitors them, and automatically restarts them if any of them fail.
Scaling: If more users need your app, Kubernetes can increase the number of Pods to handle the extra traffic.
Updates: When you update your app, Kubernetes replaces the old Pods with new ones, gradually updating your app without causing downtime.

In summary, Kubernetes simplifies the management of containerized applications by automating tasks like deployment, scaling, and updating. While it may seem complex at first, understanding the key concepts like clusters, Pods, deployments, and services can make it an incredibly powerful tool for keeping your apps running smoothly and efficiently.

Happy coding!

Docker is easier than you think!

Idil Saglam — Fri, 27 Sep 2024 13:46:43 +0000

I promise that after reading this post, you'll understand what Docker does and how it works. Docker might seem a bit abstract at first, but it's a really useful tool for developers. I read so many articles about it, but it's simpler than you think!

I'm going to explain Docker in the simplest terms possible so you can understand why it's important to use and how it can easily fit into your projects. Let's dive in!

Let's say you built an app on your laptop and it works great. But then when you send it to your friend, it doesn't work on their computer.🥺

Why? Your friend's computer might have a different version of the software or need certain tools for your app to run. This can be frustrating, huh? I don't even talk about the cases in which you don't send your cool app to a friend to try it, so it can cause massive problems if it's a job interview or a project you delivered to your client.

It would be great if you could create a box that includes everything it needs to work. No matter where you send this box—to your friend's computer, a server, or even the cloud—it will work the same way.

Good news is that it exists, and it is called a container on Docker.🥳

What is Docker?

Docker is like the creators of these boxes. It helps you package your app and everything it needs into a box (container). Inside the box, there is

Your code
All the tools and libraries your app needs to run
Settings that make sure your app runs correctly

Once your app is inside this Docker box, it can run anywhere. You don't have to worry about whether it will work on different computers or environments because everything your app needs is already packed inside!

Why use Docker?

Your app works the same everywhere, whether on your laptop, your friend's computer, or a remote server.
Each app runs in its own box, so there are no conflicts with other apps.

You can easily share this Docker container with others, and it will work right out of the box, no extra setup needed.

Fancy terms that you need to understand

Dockerfile:

It tells Docker what to put in the box (container) and how to set everything up. For example, if your app uses Node.js, you tell Docker in the Dockerfile to install Node.js inside the container.

FROM node:14     # Start with a basic Node.js environment
WORKDIR /app     # Create a folder in the container for your app
COPY . .         # Copy your app code into the container
RUN npm install  # Install all the necessary packages
EXPOSE 3000      # Make sure port 3000 is available
CMD ["npm", "start"] # Start your app

Docker image:

Docker image doesn't actually do anything by itself, but it contains everything needed to set up and run your app when turned into a container. Here is an analogy that I like to explain what docker image is:

Think of a Docker image like a frozen pizza you buy from the store:
When the pizza is frozen, you can't eat it yet. But it has everything you need to make a meal: the dough, sauce, cheese, and toppings are all there.You just need to put it in the oven (run it) to make it ready to eat.

Similarly, a Docker image has all the things your app needs to run (code, software, libraries). It's like the frozen version of your app.

So in the docker image there is your code, dependencies that your app needs and any special settings your app needs to work correctly.

Docker container

Is a running instance of a docker image. In our analogy its like putting that frozen pizza in the oven and baking it. Now, the pizza is hot and ready to eat, meaning it's actually useful.

Good to know

Docker image is just a package with your app and all the dependencies
Docker container is when you tell Docker to "run" the image it creates a container. This container is where your app is actually running.

In Super Simple Terms:
Docker is like putting your app in a box so it works the same everywhere.Inside this box, your app has everything it needs to run (the right version of Node.js, libraries, etc.).

You can send this box (Docker container) to anyone, and it will work without any issues, even if their computer is different.

Why You Should Care:

You don't need to worry about things like "It works on my computer but not on the server."It's easy to share your app with others, and they can run it with a single command.You can avoid all the messy setup of environments and dependencies!

In short, Docker helps you create a clean, isolated environment for your app that you can run anywhere, without worrying about things breaking because of differences in the environment.
Hope its clearer now.

Use web components!!!!!

Idil Saglam — Wed, 25 Sep 2024 21:56:24 +0000

Creating reusable and modular components in modern web development is essential for maintaining clean, scalable, and efficient code. Whether building a simple website or a complex application, web components can simplify your workflow.

Web components allow developers to create custom, reusable HTML elements across different projects and frameworks.

To understand what web components are, you need to understand mainly 3 things:

Custom elements:

Creating custom elements is like creating your HTML tags. What does it mean? 🤯

In an HTML file, you get the same thing each time you use <h1> tag. You know that every time you use that <h1> tag, you'll get the same result by default.

So imagine that you're building a quiz app in which there will be lots of quizzes. Your quizzes will have the same layout and logic: There will be a question and answer options. After completing the quiz, the users' results will be calculated.

So, the only thing that will be different for each quiz will be the topic of the questions and their answers. The main HTML will remain the same.

It would be great and time-saving for you to have a quiz tag, just like you have an <h1> tag in HTML, right?

Using web components, you can create your own quiz element and call it like an HTML tag in your code. It's time-saving, easy to use, and makes the code much readable.

One of the best parts is that if you decide to change one thing on the quiz, for example, if you want to change your layout for all quizzes, you'll only have to update your web component file and boom! All your quizzes will automatically be updated. Amazing!

Here is an example of creating a custom element and how to call it on a HTML file:

class MyElement extends HTMLElement {
constructor() {
super();
this.attachShadow({ mode: 'open' });
this.shadowRoot.innerHTML = `<p>Hello, Web Components!</p>`;
}
}
customElements.define('my-element', MyElement);

You can then use<my-element></my-element>in your body tag of your HTML.

The Shadow DOM

Shadow DOM is part of the web components standard that allows you to encapsulate a component's internal structure and styling. When we create custom web components, we use them like HTML tags. But what happens if we have multiple similar web components on the same page? Without encapsulation, styles from one component might interfere with others or the rest of the page. Shadow DOM prevents this by ensuring that each component's styles and structure are isolated and won't affect anything outside the component, and vice versa.

Why is it important?

In this way, the styles and structure inside a component are scoped only to that component. So, the external styles (css of the rest of the page) won't affect the component.
Styles of the component won't affect the rest of the page.

So why you should use web components?

Keeps styles and scripts isolated from the rest of the page
Once created, you can use web components across different projects and contexts.
It works with any framework or vanilla JavaScript.

The Power of Conventional Commits ✨✨

Idil Saglam — Sat, 16 Mar 2024 10:43:54 +0000

In the world of software development, the art of communication is just as important as the code itself. This article aims to demystify Conventional Commits, exploring their benefits and how they can transform your project's collaboration and versioning.

What Are Conventional Commits?

Conventional Commits refer to a lightweight, easy-to-follow convention for writing clear and descriptive commit messages.

✨✨ The idea is simple: ✨✨
Structure your commit messages in a predictable manner that clearly communicates the nature of the change to other developers and automated tools.

A basic Conventional Commit message might look like this:

feat(login): add the remember me checkbox

This message is broken down into three parts:

feat: A prefix indicating the type of change. In this case, a new feature.
(login): An optional scope to provide additional contextual information. Here, it specifies that the change affects the login feature.
add the remember me checkbox: A succinct description of the change.

Why Conventional Commits, what are the benefits of it?

1. Improved Readability 👀
Commit history becomes significantly more readable and understandable. This clarity is invaluable for new team members, code reviews, and anyone trying to understand the evolution of a project.

2. Automated Versioning and Changelog Generation
Tools like Semantic Release can parse these structured commit messages to automate versioning and changelog generation, streamlining your release process and ensuring consistent version management.

3. Enhanced Collaboration
Clear commit messages set a standard for project communication, reducing ambiguities and misunderstandings. This is particularly crucial in distributed teams where asynchronous communication dominates.

4. Better Discipline
The requirement to consider the commit message format naturally encourages developers to commit coherent, self-contained changes, leading to a cleaner, more organized commit history.

Conclusion

Conventional Commits offer a simple yet powerful way to enhance your project's communication, versioning, and collaboration. By adopting this practice, you improve your project's maintainability and foster a culture of clarity and precision in your development team. Start small, integrate tooling to support the process, and watch your project's commit history transform into a well-organized, informative log that serves as documentation and a communication tool.

Happy coding, and may your commits always be conventional!

Mastering Java and Spring Boot

Idil Saglam — Mon, 15 Jan 2024 20:43:34 +0000

Java is a dominant and preferred programming language for many developers. With the Spring Boot, Java's capabilities have been significantly enhanced, offering a robust framework for building modern, scalable applications.

Java is a high-level programming language renowned for its stability, security, and cross-platform capabilities.

Object-Oriented Programming (OOP): Java's OOP model simplifies complex software development, promoting code reusability, scalability, and maintenance.

Platform Independence: Java's "write once, run anywhere" philosophy is realized through the Java Virtual Machine (JVM), making it a versatile choice for diverse environments.

Rich API and Powerful Development Tools: Java's extensive API and tools like Eclipse and IntelliJ IDEA enhance developer productivity and application performance.

Spring Boot: Simplifying Java Application Development
Spring Boot, a project under the larger Spring framework, revolutionizes Java application development by simplifying the setup and deployment process. It's designed to get your applications up and running as quickly as possible with minimal configuration.

Convention over Configuration: Spring Boot's approach minimizes the need for explicit configuration, reducing development time and potential errors.
Standalone Applications: It enables the creation of standalone, production-grade applications that you can "just run."

Microservices Ready: Spring Boot is an excellent choice for building microservices, offering lightweight components and cloud-ready features.
Key Features of Spring Boot

Auto-Configuration: Spring Boot automatically configures your application based on the added dependencies.
Spring Initializr: A web-based tool that helps in project setup and dependency management.

Actuator: Provides built-in endpoints for monitoring and managing application health.

Building a Simple Application with Java and Spring Boot
To understand the practical implementation, let's create a basic RESTful web service using Java and Spring Boot.

Setting Up: Use Spring Initializr to generate a Maven or Gradle project with required dependencies.
Coding: Develop your application using Spring Boot's easy-to-use annotations and classes.

Running the Application: Run your application with a simple command or through your IDE.
Advantages of Using Java with Spring Boot

Increased Productivity: With less code and easier configuration, developers can focus more on business logic rather than boilerplate code.

Enhanced Performance: Java's performance combined with Spring Boot's optimization features results in high-performance applications.

Community and Support: Both Java and Spring Boot have a large, active community, ensuring a wealth of resources and support.
Conclusion

Java, combined with Spring Boot, offers a powerful duo for building efficient, robust, and scalable applications. Whether you're new to programming or an experienced developer, mastering Java and Spring Boot can significantly elevate your development capabilities, preparing you for the challenges of modern software development.

Navigating the Digital Frontier: The Life of a Remote Developer

Idil Saglam — Wed, 27 Sep 2023 09:14:56 +0000

In the modern world, the term ‘office’ has metamorphosed beyond the traditional brick-and-mortar setting. It has transcended into a digital frontier where remote developers are pioneering innovations from the comfort of their homes. Amidst the change, companies have broadened their horizons, harnessing talents from every corner of the globe. This paradigm shift brings forth a blend of opportunities and challenges.

The Freedom of Flexibility

A prominent allure of being a remote developer is the enviable flexibility it offers. Freed from the daily commute, developers reclaim precious hours which can be redirected towards productivity, continuous learning, or personal pursuits. The flexibility extends to working hours as well, allowing for a healthier work-life balance, which in turn, cultivates a conducive environment for creativity and problem-solving.

Worldwide Opportunities

Being a remote developer dismantles geographical barriers, opening doors to global opportunities. This digital liberation permits developers to collaborate with international teams, contribute to projects half a world away, and engage in a cross-cultural exchange of ideas. It's a fertile ground for learning, growing, and networking.

The Toolbox of Technology

With a plethora of tools like Slack, Zoom, GitHub, and Trello, communication and collaboration have never been smoother. These digital utilities ensure that teams stay connected and projects stay on track. The technological ecosystem facilitates seamless interactions, real-time feedback, and collective problem-solving, mirroring the dynamism of a physical workspace.

The Challenges of Isolation

On the flip side, remote development can sometimes be a solitary endeavor. The lack of face-to-face interactions might lead to feelings of isolation or detachment from the team. Moreover, navigating through project requirements or tackling roadblocks may take longer when communication is a barrier.

Building a Robust Remote Culture

Creating a robust remote culture is imperative for the success of a remote developer. Scheduled virtual meet-ups, clear communication protocols, and a strong support system are essential elements. Encouraging a sense of community and inclusiveness can bridge the physical distance and foster a collaborative spirit among remote developers.

Continual Learning and Adaptability

The digital landscape is ever-evolving, necessitating a culture of continual learning and adaptability among remote developers. Staying updated with the latest technologies, tools, and best practices is quintessential for thriving in the remote development realm.

Conclusion
Being a remote developer is both a rewarding and demanding profession. The digital workspace offers boundless opportunities for growth, learning, and collaboration. However, the road is not devoid of challenges. Overcoming the hurdles of remote communication and fostering a strong remote culture are crucial for navigating the realms of remote development successfully. The expedition through the digital frontier is an exciting, albeit demanding, endeavor that promises a wealth of experience and a reservoir of opportunities for those daring to traverse it.

Exploring Mobile App Development with React Native

Idil Saglam — Wed, 26 Jul 2023 18:35:09 +0000

In the world of mobile app development, efficient cross-platform solutions are a holy grail. One such technology, React Native, stands out due to its capacity to render natively on both iOS and Android platforms. Invented by Facebook, this JavaScript framework has gained widespread popularity among developers and businesses alike. Here's why.

What is React Native?

React Native is a JavaScript framework for building mobile applications that run natively on both iOS and Android platforms. It’s an offshoot of React, Facebook’s JavaScript library for crafting engaging user interfaces. However, instead of targeting browsers like React does, React Native focuses on mobile platforms. The result? A seamless user experience and code reusability that hastens development timelines and reduces costs.

Building Blocks of React Native

In React Native, the building blocks are the native components. It wraps existing native code for user interface controls and exposes them to JavaScript. As a result, your React Native apps will render using real mobile UI components, not webviews, providing the same look and feel as any other mobile application.

React Native also taps into JavaScript and React, enabling you to compose a rich mobile UI from declarative components. If you're familiar with React, you'll be right at home with React Native.

Why Choose React Native?

One of the key advantages of React Native is Code Reusability. The same team can develop apps for both iOS and Android, leading to significant cost and time savings. More than that, up to 90% of the code can be shared between the two platforms.

React Native also boasts Community Support. As an open-source project, React Native is supported by a vibrant community of developers who continually contribute to making the framework better. This means you can leverage plenty of third-party plugins and libraries.

Performance is another area where React Native shines. Unlike hybrid frameworks that render code via webviews, React Native allows components to be rendered as native platform widgets, leading to improved performance.

Hot Reloading is a distinctive feature that increases development speed. This feature refreshes the UI instantly as developers adjust the code, allowing them to see changes in real time.

React Native in the Real World

Major corporations use React Native. Facebook, of course, uses it for their Ads Manager app. Instagram, after being acquired by Facebook, integrated React Native into their existing native app for push notifications and saved posts.

Other notable mentions include Walmart, which used React Native to improve performance of their app, and Bloomberg, which developed their consumer mobile app using this technology.

Starting with React Native

To start with React Native, you need to have Node.js and npm (node package manager) installed on your computer. Also, install the Expo CLI, which helps you create and manage your React Native projects.

Create a new project with expo init AwesomeProject, navigate into the project using cd AwesomeProject, and start your app with npm start.

Conclusion

React Native is a revolutionary framework that is changing the landscape of mobile app development. Its ability to deliver native-like performance, coupled with significant time and cost savings, makes it an attractive choice for businesses and developers. Whether you are planning to build a new app or thinking about migrating an existing one, React Native could be a great choice.

Demystifying Kubernetes: A Comprehensive Overview

Idil Saglam — Tue, 16 May 2023 12:38:27 +0000

Introduction

In the constantly evolving world of technology, Kubernetes has emerged as a game-changing solution in the realm of container orchestration. The open-source platform, originally developed by Google, is now maintained by the Cloud Native Computing Foundation (CNCF). But what exactly is Kubernetes? This blog post aims to demystify Kubernetes, breaking down its complexities into digestible insights.

What is Kubernetes?

Kubernetes, also known as K8s, is an open-source system designed to automate the deployment, scaling, and management of containerized applications. Containers package an application with all its dependencies, allowing it to run uniformly across different computing environments.

Kubernetes steps in to solve a crucial problem: How do you manage these containers at scale? With Kubernetes, you can efficiently coordinate and automate a vast array of containers, ensuring that your applications run smoothly and reliably, no matter the scale.

Why Kubernetes?

Before the advent of Kubernetes, managing and scaling containerized applications was no simple task. Kubernetes brought several benefits to the table:

1.Scalability: Kubernetes can quickly and efficiently scale out or scale in applications based on demand.

2.High Availability: Kubernetes ensures that your applications are always up and running, reducing the risk of downtime.

3.Portability: With Kubernetes, applications can be run anywhere without needing to change the underlying code. This allows for seamless migration and multi-cloud strategy implementation.

4.Automated Rollouts & Rollbacks: Kubernetes can handle updates and rollbacks automatically, reducing the risk of errors and downtime during these processes.

5.Self-healing: Kubernetes has the ability to detect and replace unhealthy containers, ensuring that the system is functioning correctly at all times.

6.Secret and Configuration Management: Kubernetes allows you to manage and store sensitive information, such as passwords and API keys, securely and deploy configuration changes without rebuilding your container images.

Conclusion

In the fast-paced world of software development, Kubernetes has emerged as a powerful ally. Its robust capabilities in orchestrating and managing containers have revolutionized the way businesses deploy and scale their applications. With its unique features such as scalability, high availability, automated rollouts and rollbacks, and self-healing, Kubernetes ensures that our applications run smoothly and reliably, regardless of scale or complexity.

However, as with any technology, Kubernetes is not a one-size-fits-all solution. It's a complex system that requires a good understanding to exploit its full potential. Therefore, businesses and developers should thoroughly assess their needs and capabilities before diving into Kubernetes.

In conclusion, Kubernetes is more than just a buzzword in the tech industry. It's a powerful tool that has significantly improved how we handle containerized applications, making our digital lives more efficient and reliable. As we move towards an increasingly cloud-native future, Kubernetes' role is set to become even more pivotal, shaping the evolution of software deployment and management.

Creating a Simple Go Application for CRUD Operations with Neo4j and Docker

Idil Saglam — Thu, 30 Mar 2023 12:01:02 +0000

Hi everyone 👋, today we'll create a simple Go application that demonstrates basic CRUD operations using Neo4j 🏢, a popular graph database, and Docker 🐳. This tutorial will guide you through the steps to set up a local Neo4j instance using Docker, connect to it from your Go application using the Neo4j Go driver 🚗, and perform CRUD operations on a sample data set. By the end of this tutorial, you'll have a solid understanding of how to use Neo4j with Go and Docker to build scalable and efficient graph-based applications 🚀. So, let's get started!

Neo4j is a popular graph database that allows users to store, manage, and retrieve data using graph-based queries 📊. Go is a popular programming language for building scalable and efficient applications 🚀. In this tutorial, we'll learn how to create a simple Go project that uses Neo4j and Docker to perform CRUD operations.

Prerequisites

Before we begin, please ensure that you have the following installed on your system:

Docker 🐳
Go (version 1.16 or higher)
The neo4j-go-driver package (version 4 or higher)

Setting up a Neo4j Database with Docker 🐳

First, we need to set up a Neo4j database using Docker 🐳. Open your terminal and execute the following command:

docker run --name neo4j -p 7687:7687 -p 7474:7474 -e NEO4J_AUTH=neo4j/test1234 neo4j:latest
This command will create a new Docker container with a Neo4j database running on port 7687 (for Bolt) and 7474 (for HTTP)🚀. We're also setting the NEO4J_AUTH environment variable to neo4j/test1234 to specify the initial password for the neo4j user.

Creating a New Go Project

Next, we need to create a new Go project. Create a new directory for the project and navigate into it:

mkdir my-neo4j-project
cd my-neo4j-project

Create a new Go module for the project:

go mod init my-neo4j-project

This will create a new go.mod file in the project directory.

Now, let's take a look at the code! 🔍

Import statements

import (
    "fmt"
    "github.com/neo4j/neo4j-go-driver/v4/neo4j"
    "log"
)

The import statements include the necessary packages to interact with Neo4j database and log errors.

Create a person struct

type Person struct {
    ID   int64
    Name string
    Age  int
}

The Person struct represents the structure of a "Person" node in the Neo4j database 🧑. It has an ID, name, and age field.

Write the Main function

func main() {
    // create a new Neo4j driver
    driver, err := neo4j.NewDriver("bolt://localhost:7687", neo4j.BasicAuth("neo4j", "test1234", ""))
    if err != nil {
        log.Fatalf("Failed to create Neo4j driver: %v", err)
    }
    defer driver.Close()

The main function is the entry point of the application. It creates a new Neo4j driver instance by providing the bolt URL and authentication credentials 🔐.

Create a Person

Let's start by creating a new person. We define a createPerson function that takes in the Neo4j driver instance, the person's name, and age as arguments. Inside the function, we create a new session using the driver and then execute a Cypher query to create a new Person node with the given name and age. We then extract the ID of the created node from the result and return a new Person struct with the ID, name, and age.

func createPerson(driver neo4j.Driver, name string, age int) (*Person, error) {
    session := driver.NewSession(neo4j.SessionConfig{})
    defer session.Close()

    result, err := session.Run(
        "CREATE (p:Person {name: $name, age: $age}) RETURN id(p)",
        map[string]interface{}{"name": name, "age": age},
    )
    if err != nil {
        return nil, err
    }

    record, err := result.Single()
    if err != nil {
        return nil, err
    }

    id, ok := record.Values[0].(int64)
    if !ok {
        return nil, fmt.Errorf("invalid ID type")
    }

    return &Person{ID: id, Name: name, Age: age}, nil
}

Get a Person by Name

Next, we define a getPersonByName function that takes in the Neo4j driver instance and a person's name as arguments. Inside the function, we create a new session using the driver and then execute a Cypher query to find a Person node with the given name. We limit the result to one record and extract the ID and age of the node from the result. We then return a new Person struct with the ID, name, and age.

func getPersonByName(driver neo4j.Driver, name string) (*Person, error) {
    session := driver.NewSession(neo4j.SessionConfig{})
    defer session.Close()

    result, err := session.Run(
        "MATCH (p:Person) WHERE p.name = $name RETURN id(p), p.age LIMIT 1",
        map[string]interface{}{"name": name},
    )
    if err != nil {
        return nil, err
    }

    record, err := result.Single()
    if err != nil {
        return nil, err
    }

    id, ok := record.Values[0].(int64)
    if !ok {
        return nil, fmt.Errorf("invalid ID type")
    }

    age, ok := record.Values[1].(int64)
    if !ok {
        return nil, fmt.Errorf("invalid age type")
    }

    return &Person{ID: id, Name: name, Age: int(age)}, nil
}

Get a Person by ID

We also define a getPersonByID function that takes in the Neo4j driver instance and a person's ID as arguments. Inside the function, we create a new session using the driver and then execute a Cypher query to find a Person node with the given ID. We extract the name and age of the node from the result and return a new Person struct with the ID, name, and age.

func getPersonByID(driver neo4j.Driver, id int64) (*Person, error) {
    session := driver.NewSession(neo4j.SessionConfig{})
    defer session.Close()

    result, err := session.Run(
        "MATCH (p:Person) WHERE id(p) = $id RETURN p.name, p.age",
        map[string]interface{}{"id

Update person age

The updatePersonAge function takes in a Neo4j driver object, the ID of the person whose age needs to be updated, and the new age. It then creates a new session using the driver and executes a Cypher query that updates the person's age based on the provided ID. The Cypher query starts with the MATCH keyword, which finds the person node with the given ID. The SET keyword is used to set the person node's age property to the new age provided. Finally, the RETURN keyword is used to retrieve the person node's name and updated age.

Once the Cypher query has executed successfully, the function constructs a Person struct containing the updated ID, name, and age. This Person struct is then returned by the function.

func updatePersonAge(driver neo4j.Driver, id int64, age int) (*Person, error) {
    session := driver.NewSession(neo4j.SessionConfig{})
    defer session.Close()

    result, err := session.Run(
        "MATCH (p:Person) WHERE id(p) = $id SET p.age = $age RETURN p.name, p.age",
        map[string]interface{}{"id": id, "age": age},
    )
    if err != nil {
        return nil, err
    }

    record, err := result.Single()
    if err != nil {
        return nil, err
    }

    name, ok := record.Values[0].(string)
    if !ok {
        return nil, fmt.Errorf("invalid name type")
    }

    newAge, ok := record.Values[1].(int64)
    if !ok {
        return nil, fmt.Errorf("invalid age type")
    }

    return &Person{ID: id, Name: name, Age: int(newAge)}, nil
}

Delete person

The deletePerson function takes in a Neo4j driver object and the ID of the person to be deleted. It creates a new session using the driver and executes a Cypher query that deletes the person node based on the provided ID. The Cypher query starts with the MATCH keyword, which finds the person node with the given ID. The DELETE keyword is used to delete the person node.

If the deletion is successful, the function returns nil. Otherwise, it returns an error indicating that the deletion was unsuccessful.

func deletePerson(driver neo4j.Driver, id int64) error {
    session := driver.NewSession(neo4j.SessionConfig{})
    defer session.Close()

    _, err := session.Run(
        "MATCH (p:Person) WHERE id(p) = $id DELETE p",
        map[string]interface{}{"id": id},
    )
    if err != nil {
        return err
    }

    return nil
}

Putting it All Together

Now that we have defined the necessary functions for CRUD operations, let's put them together in the main function. The main function demonstrates how to create, get, update, and delete a Person node in the Neo4j database.

func main() {
    // create a new Neo4j driver
    driver, err := neo4j.NewDriver("bolt://localhost:7687", neo4j.BasicAuth("neo4j", "test1234", ""))
    if err != nil {
        log.Fatalf("Failed to create Neo4j driver: %v", err)
    }
    defer driver.Close()

    // create a new person
    person, err := createPerson(driver, "Alice", 30)
    if err != nil {
        log.Fatalf("Failed to create person: %v", err)
    }
    log.Printf("Created person: %+v\n", person)

    // get the person by name
    personByName, err := getPersonByName(driver, "Alice")
    if err != nil {
        log.Fatalf("Failed to get person by name: %v", err)
    }
    log.Printf("Found person by name: %+v\n", personByName)

    // get the person by ID
    personByID, err := getPersonByID(driver, person.ID)
    if err != nil {
        log.Fatalf("Failed to get person by ID: %v", err)
    }
    log.Printf("Found person by ID: %+v\n", personByID)

    // update the person's age
    updatedPerson, err := updatePersonAge(driver, person.ID, 35)
    if err != nil {
        log.Fatalf("Failed to update person's age: %v", err)
    }
    log.Printf("Updated person: %+v\n", updatedPerson)

    // delete the person
    err = deletePerson(driver, person.ID)
    if err != nil {
        log.Fatalf("Failed to delete person: %v", err)
    }
    log.Printf("Deleted person with ID %d\n", person.ID)
}

The main function first creates a new Neo4j driver instance and then creates a new person node with the name "Alice" and age 30. It then retrieves the person node by name and ID and prints the results. The function then updates the person's age to 35 and prints the updated person. Finally, it deletes the person node and prints a message indicating that the person was deleted.

Conclusion

In this tutorial, we learned how to create a simple Go application that uses Neo4j and Docker to perform CRUD operations on a sample data set. We first set up a Neo4j database using Docker and then defined the necessary functions for creating, getting, updating, and deleting a Person node in the Neo4j database. We then put these functions together in the main function to demonstrate how to perform CRUD operations on a sample data set.

By the end of this tutorial, you should have a solid understanding of how to use Neo4j with Go and Docker to build scalable and efficient graph-based applications. I hope you found this tutorial helpful, and please feel free to leave any comments or questions below! 👋