投稿者: 管理者

As part of our engineer blog, we introduce the topics we are actively learning.
This time, we focus on low-code tools!

Theme: Trends in Low-Code Tools

In our previous blog post, “Trends in Low-Code Tools” – dandelionS Blog, published in July 2021, we discussed the latest developments in low-code tools.

Since then, more of our team members have gained experience with OutSystems, prompting us to conduct another trend analysis to explore the future outlook of low-code tools.

What Are Low-Code and No-Code?

The adoption of low-code and no-code tools is increasing to improve app development efficiency, enabling faster development and cost reduction.

• Low-Code: Requires minimal coding for app development. Some programming knowledge is necessary, but it allows for flexible customization.
• No-Code: Enables intuitive app creation without coding. However, customization options are more limited.

[Comparison table with representative tools]

Comparison of Major Low-Code & No-Code PlatformsThe market share of low-code and no-code platforms is primarily based on industry recognition and the number of companies adopting them. Below are the leading platforms ranked by market share:

Microsoft Power Apps

A widely adopted platform due to its strong integration with Microsoft products (especially Office 365 and Azure). As part of the Microsoft ecosystem, it allows businesses to easily create and manage applications.

• Adoption: Used by organizations of all sizes worldwide, from small businesses to large enterprises.

OutSystems

A low-code platform specializing in enterprise solutions, excelling in large-scale and complex app development. It features strong automation and AI functionalities and is particularly popular among large corporations.

• Adoption: Commonly used in industries like finance, manufacturing, and public institutions.

Mendix

A low-code platform designed for enterprise applications, known for its integration with SAP and industry-specific approach. It supports both cloud-based and on-premises deployment, providing an advanced development environment.

• Adoption: Frequently used in manufacturing and logistics industries.

Appian

Specialized in Business Process Management (BPM), this platform excels in process automation and complex workflow management. It is designed for enterprises looking to optimize business operations.

• Adoption: Popular in industries such as banking, insurance, and pharmaceuticals.

Future of Low-Code and No-Code

The future of low-code and no-code tools looks promising, with market growth and technological advancements driving increased adoption. The integration of AI will further enhance development speed and expand possibilities for both enterprises and individual developers.

Market Growth

• The global low-code/no-code market was valued at $17 billion in 2022.
• It is projected to grow to $45 billion by 2027.
• The market is expected to expand rapidly over the next 5–10 years.

Key Trends in the Low-Code/No-Code Market

Stronger Integration Between AI & Low-Code/No-Code
AI will automate development processes, allowing for natural language-based app development, eliminating the need for manual coding. Additionally, AI will optimize UI/UX design and code generation.

Examples of AI Integration:

• Power Apps’ “Copilot” and OutSystems’ “AI Mentor”
• Developers can input commands like “Create a product management app”, and AI will automatically generate the application.
• AI will analyze user behavior and optimize UI layout automatically.
• With further AI advancements, even complex logic and data analysis will be handled by AI, accelerating the shift toward true no-code development.
• Developers’ roles will transition from coding to designing and managing applications.

Conclusion

Based on market share, Microsoft Power Apps dominates the low-code space due to its strong integration with Microsoft’s ecosystem. However, OutSystems also maintains a strong position, particularly in enterprise applications.

While large enterprises have been the primary adopters, the question remains whether low-code tools will expand further into SMEs and general users.

Looking ahead, as low-code tools and AI continue to merge, developers will focus more on designing applications, while AI handles coding. Exploring how OutSystems can integrate with AI will be a key consideration moving forward.

For our next post, we’ll explore the potential of OutSystems and AI integration and what it can achieve. Stay tuned!

In this engirring blog, we introduce the learning topics we work on daily.

What is Local-First?

Recently, the concept of Local-First has been gaining attention. Many applications are designed with an online-first approach, where data is stored in the cloud. This allows users to access their data from any device and easily share it with others. However, applications that rely on online connectivity have several disadvantages, such as:

• Data is inaccessible without an internet connection.
• The application becomes unusable if the server goes down.
• Communication with the server can introduce delays, reducing responsiveness.
• Storing personal data in the cloud poses security risks from external access.

The Local-First approach addresses these issues. In Local-First applications, data is primarily stored on the user’s device and synchronized only when needed. This approach offers several benefits:

• Data remains accessible even without an internet connection.
• The application functions independently, unaffected by service outages.
• Immediate data read/write operations without relying on a server.
• Personal data is managed locally, reducing dependency on the cloud.

Examples of Local-First Applications

Several applications utilize the Local-First approach, including:

• Evernote: Allows users to create and view notes even while offline. Synchronization with the cloud ensures data availability across devices.
• Notion: An all-in-one productivity tool featuring document management, task tracking, and database functionality. Users can edit content offline, and changes are synced to the cloud to maintain data consistency.

Let’s Build an Application! (TypeScript Edition)

To experience the Local-First approach, let’s build a simple To-Do App that runs entirely within a browser! This application will store data locally, ensuring that tasks remain saved even after a page reload.

Below, we introduce the key implementation details.

ToDo の追加（データをローカルに保存）
async function addTodo(text: string) {
    const todo = {
        _id: new Date().toISOString(),  // 一意のID
        text,
        completed: false
    };
    // データをローカルに保存
    await db.put(todo);
}

ToDo の表示（保存されたデータを取得）
async function renderTodos() {
    const result = await db.allDocs({ include_docs: true });
    result.rows.forEach(row => {
        // タスクを取得して表示
        console.log(row.doc.text);
    });
}

ToDo の削除
async function deleteTodo(id: string) {
    const doc = await db.get(id);
    // タスクを削除
    await db.remove(doc);
}

Running the To-Do App

1. Open the application in a web browser.
2. Enter a task and click the Add button—the task will be added to the list below.
3. Close the browser. (Normally, this would cause the entered tasks to be lost.)
4. Reopen the application in the browser. (The previously entered tasks remain displayed.)
5. Click on a task to delete it.

Thoughts on Running the App

One of the standout features of this To-Do App is its ability to function independently of the internet, managing data entirely within the browser. By storing data locally, users can continue using the application even while offline.

Key Takeaways:

• Data persists even after a page reload!
• The app works without a server!
• Fast performance with instant data retrieval!

Applications that don’t rely on servers or the cloud might seem somewhat uncommon, but the Local-First approach proves to be highly valuable for offline functionality and data privacy. While this project was a simple implementation, it could be extended with cloud synchronization or mobile support for a more versatile experience.

Exploring the possibilities of Local-First applications has been insightful, and I look forward to leveraging this concept further.

See you in the next blog post!

Welcome to our engineer blog, where we share our ongoing learning experiences. This post is part of Unit 0, which focuses on web design. Today, I’d like to introduce an opportunity I had to work with something less commonly encountered: QR code generation.

Preparation

For this implementation, I used Java. Since my development environment is Gradle-based, adding the necessary libraries was as simple as including the following in the build.gradle file. (Isn’t it convenient how accessible things have become these days?)

Reference Site:
Getting Started Developing · zxing/zxing Wiki · GitHub

The library used here is ZXing, an open-source Java library that enables the creation and reading of one-dimensional codes (such as barcodes) and two-dimensional codes (like QR codes).

Implementation

The key element for generating QR codes is the encode method of the QRCodeWriter class. As summarized in the comments, the following parameters can be specified:

1. First parameter: The content to be displayed.
2. Second parameter: The output format ( BarcodeFormat from the ZXing 3.5.3 API).
3. Third parameter: The dimensions.

The generated data is stored in a variable of type BitMatrix (bm). By specifying the output format in the writeToStream method, you can save the generated QR code in your desired format. In this case, we output the QR code in PNG format.

While the actual implementation involves handling API requests and returning the output result to the screen, I’ll omit those details here.

Summary

Nowadays, if you just want to generate a QR code once for testing purposes, there’s no need to write a program from scratch. You can find many online QR code generators with just a quick search. Some even let you customize the design or offer formats tailored to specific use cases, making them surprisingly fun to explore.

This post covered only the basics, but I hope it gave you an idea of how QR code generation works. If you found this interesting, I’d be delighted.

Stay tuned for the next engineer blog post!

P.S. The content of the QR code includes a closing message!

Hello! I’m Ogi, responsible for this edition of our study session blog. I’m excited to share the highlights of our recent internal training session, “Low-Code Development Experience Using Outsystems Part 2”!

Check out the highlights from our previous study session here!

Building on our last session, the goal of this study meeting was to deepen our understanding of low-code development and Outsystems by gaining hands-on experience with Outsystems development. This time, we had many new members join us, making the session even more vibrant and engaging.

Here’s how the study session unfolded:

1. Recap of the Previous Session
2. Watching Educational Videos – Focus on UI Development
3. Hands-On Development with Outsystems
4. Summary and Q&A

Watching Educational Videos – Focus on UI Development

We kicked off the session by watching official educational videos provided by Outsystems. This time, the videos focused on UI development, where we learned the basics of screen widgets, variables, and client-side logic.

If you’re interested, you can watch the videos here (an Outsystems account is required).

Hands-On Development with Outsystems

After watching the videos, each participant used their own Outsystems environment to start developing. During this hands-on session, we primarily focused on:

• Adding Widgets and Logic to Screen
• Utilizing Aggregates ( Learn more about Aggregates here.)
• Displaying Data on Screen

We experienced firsthand the unique advantages of developing with Outsystems, such as the simplicity of adding widgets through drag-and-drop and the visual manipulation capabilities provided by Aggregates for data retrieval and sorting.

Throughout the development process, we followed the instructor’s explanations and worked on our own projects, enhancing our practical skills.

Summary

In this study session, we tackled more hands-on content compared to the previous one, successfully conveying the benefits of low-code development and Outsystems. The development experience segment fostered active discussions and Q&A among the participants, further deepening our understanding.

We plan to continue hosting study sessions focused on Outsystems development in the future. Stay tuned for our next article!