KAS GUI | A Widget-first GUI toolkit Written in Rust

KAS GUI

KAS is a widget-first GUI toolkit:

• widgets retain state
• flexibile drawing, layout, event handling, animation
• clean, type-safe widget interaction
• full keyboard control of UI
• fast, efficient, responsive

Features

• Good automatic layout (margins, text wrapping width-for-height logic)
• Partially declarative UI descriptions possible through macros
• Advanced text features: shaping, bidirectional support, font fallbacks
• Embedded GPU shaders (see Mandlebrot example)
• Supports theming and end-user configuration
• View widgets for seemless scrolling and sharing of large data
• Stepless DPI scaling:

Limitations

• Slow compile times. See Faster builds.
• Somewhat large binaries; e.g. for the gallery example: 333M (debug), 38M (debug + strip), 20M (release), 12M (release + strip). Note that these binaries are statically linked, as is the norm for Rust. Some improvements may be possible, e.g. disabling features such as shaping and image or replacing the rendering backend.

Documentation

• Wiki: Getting started, Configuration, Troubleshooting
• API docs: https://docs.rs/kas, https://docs.rs/kas-core, https://docs.rs/kas-widgets, https://docs.rs/kas-theme, https://docs.rs/kas-wgpu
• KAS Tutorials
• Changlelog
• Roadmap
• Discuss
• KAS Blog

Examples

See the examples directory and kas-gui/7guis.

Precompiled example apps can be downloaded as follows:

• go to https://github.com/kas-gui/kas/actions/workflows/build.yml
• select the latest (complete) run
• download one of the examples-* artifacts

Design

Data or widget first?

KAS uses a widget-first design: widgets are persistent and retain state; data must be pushed into widgets. Many modern UIs are data-first: widgets are built per-frame over a single persistent data object. There are significant trade-offs of a widget-first design:

• (for) widgets have embedded state; data-first designs may require explicitly connecting widgets to state, for those that need it
• (against) dynamic layout is harder
• (for) updates are fast since only affected widgets need be touched; using 10,000+ widgets in a UI is not a problem
• (against) rebuilding the UI is much slower
• (for) pre-built "view widgets" with built-in support for scrolling over large external databases (only retrieving visible entries)
• (against) "view widgets" are an emulation of data-first design over a widget-first model, and less flexible

Crates and features

Crates

• kas is a meta-package; most of the time this is the only one you need to use directly
• kas-macros: a helper crate for proc macros
• kas-core provides most interfaces and logic concerning widgets (event handling, layout, draw API, geometry types)
• KAS-text: provides text layout and font management
• kas-widgets: the standard widget library
• kas-theme: theming support for KAS (API, two themes, config support)
• kas-wgpu: provides windowing via winit and rendering via WGPU
• kas-dylib: support for dynamic linking
• https://docs.rs/easy-cast: spin-off crate for checked casts
• https://docs.rs/impl-tools: spin-off macro support crate

At this point in time, kas-wgpu is the only windowing/rendering implementation and kas-theme the only theme (high-level drawing) implementation, thus kas uses these crates by default, though they are optional.

Feature flags

The kas crate enables most important features by default, excepting those requiring nightly rustc. Other crates enable fewer features by defualt.

The following non-default features of kas are highlighted:

• dynamic: enable dynamic linking for kas (see Faster builds)
• internal_doc: turns on some extra documentation intended for internal usage but not for end users. (This only affects generated documentation.)
• nightly: enables the less problematic unstable features
• min_spec (enabled by nightly): use min_specialization for some visual improvements: scrolled regions are drawn under scroll bars, underlines on check-box accelerator keys show with the Alt key.
• spec: use specialization to enable TryFormat

For full documentation of feature flags, see the Cargo.toml.

Download Details:
Author: kas-gui
Source Code: https://github.com/kas-gui/kas
License: Apache-2.0 license

#rust #applications

Iced RS: A Cross-platform GUI Library for Rust

Iced

A cross-platform GUI library for Rust focused on simplicity and type-safety. Inspired by Elm.

Features

• Simple, easy-to-use, batteries-included API
• Type-safe, reactive programming model
• Cross-platform support (Windows, macOS, Linux, and the Web)
• Responsive layout
• Built-in widgets (including text inputs, scrollables, and more!)
• Custom widget support (create your own!)
• Debug overlay with performance metrics
• First-class support for async actions (use futures!)
• Modular ecosystem split into reusable parts:
  • A renderer-agnostic native runtime enabling integration with existing systems
  • Two built-in renderers leveraging wgpu and glow
    • iced_wgpu supporting Vulkan, Metal and DX12
    • iced_glow supporting OpenGL 2.1+ and OpenGL ES 2.0+
  • A windowing shell
  • A web runtime leveraging the DOM

Iced is currently experimental software. Take a look at the roadmap, check out the issues, and feel free to contribute!

Installation

Add iced as a dependency in your Cargo.toml:

iced = "0.4"

If your project is using a Rust edition older than 2021, then you will need to set resolver = "2" in the [package] section as well.

Iced moves fast and the master branch can contain breaking changes! If you want to learn about a specific release, check out the release list.

Overview

Inspired by The Elm Architecture, Iced expects you to split user interfaces into four different concepts:

• State — the state of your application
• Messages — user interactions or meaningful events that you care about
• View logic — a way to display your state as widgets that may produce messages on user interaction
• Update logic — a way to react to messages and update your state

We can build something to see how this works! Let's say we want a simple counter that can be incremented and decremented using two buttons.

We start by modelling the state of our application:

use iced::button;

struct Counter {
    // The counter value
    value: i32,

    // The local state of the two buttons
    increment_button: button::State,
    decrement_button: button::State,
}

Next, we need to define the possible user interactions of our counter: the button presses. These interactions are our messages:

#[derive(Debug, Clone, Copy)]
pub enum Message {
    IncrementPressed,
    DecrementPressed,
}

Now, let's show the actual counter by putting it all together in our view logic:

use iced::{Button, Column, Text};

impl Counter {
    pub fn view(&mut self) -> Column<Message> {
        // We use a column: a simple vertical layout
        Column::new()
            .push(
                // The increment button. We tell it to produce an
                // `IncrementPressed` message when pressed
                Button::new(&mut self.increment_button, Text::new("+"))
                    .on_press(Message::IncrementPressed),
            )
            .push(
                // We show the value of the counter here
                Text::new(self.value.to_string()).size(50),
            )
            .push(
                // The decrement button. We tell it to produce a
                // `DecrementPressed` message when pressed
                Button::new(&mut self.decrement_button, Text::new("-"))
                    .on_press(Message::DecrementPressed),
            )
    }
}

Finally, we need to be able to react to any produced messages and change our state accordingly in our update logic:

impl Counter {
    // ...

    pub fn update(&mut self, message: Message) {
        match message {
            Message::IncrementPressed => {
                self.value += 1;
            }
            Message::DecrementPressed => {
                self.value -= 1;
            }
        }
    }
}

And that's everything! We just wrote a whole user interface. Iced is now able to:

1. Take the result of our view logic and layout its widgets.
2. Process events from our system and produce messages for our update logic.
3. Draw the resulting user interface.

Browse the documentation and the examples to learn more!

Implementation details

Iced was originally born as an attempt at bringing the simplicity of Elm and The Elm Architecture into Coffee, a 2D game engine I am working on.

The core of the library was implemented during May 2019 in this pull request. The first alpha version was eventually released as a renderer-agnostic GUI library. The library did not provide a renderer and implemented the current tour example on top of ggez, a game library.

Since then, the focus has shifted towards providing a batteries-included, end-user-oriented GUI library, while keeping the ecosystem modular:

Troubleshooting

GraphicsAdapterNotFound

This occurs when the selected built-in renderer is not able to create a context.

Often this will occur while using iced_wgpu as the renderer without supported hardware (needs Vulkan, Metal or DX12). In this case, you could try using the iced_glow renderer:

First, check if it works with

cargo run --features iced/glow --package game_of_life

and then use it in your project with

iced = { version = "0.4", default-features = false, features = ["glow"] }

NOTE: Chances are you have hardware that supports at least OpenGL 2.1 or OpenGL ES 2.0, but if you don't, right now there's no software fallback, so it means your hardware doesn't support Iced.

Contributing / Feedback

Contributions are greatly appreciated! If you want to contribute, please read our contributing guidelines for more details.

Feedback is also welcome! You can open an issue or, if you want to talk, come chat to our Discord server. Moreover, you can find me (and a bunch of awesome folks) over the #games-and-graphics and #gui-and-ui channels in the Rust Community Discord. I go by lone_scientist#9554 there.

Demo

Download Details:
Author: iced-rs
Source Code:  https://github.com/iced-rs/iced
License: MIT license

#rust #applications

Backup GUI Targeting Backblaze's B2 API Written in Rust

Backup GUI

A functioning backup tool with a GUI, written in Rust for the Backblaze's B2 Cloud Storage.
Note that this is a backup tool - it does not provide any synchronization or downloading of the files. If you need to retrieve files, use the web interface.

Requirements

Requires a Vulkan driver on your system.
This should already be present on Windows, but you may need to install the package for your Linux distro.

You'll also need an account on Backblaze. See https://www.backblaze.com/b2/cloud-storage.html for signup and pricing.

Screenshots

Usage

Before you can use the program, it must be configured. Go into the options menu and refer to Setup

The main menu features 3 buttons, from left-to-right: file-tree, upload and options.
Before you can start uploading files, make sure the options are set correctly.

You need to go into the file-tree and select which files you want to upload.
Left click expands/collapses an entry, right click toggles whether it should be uploaded.
Red = exclude, green = include.

Once this is done, simply hit the upload button in the main menu, and it'll start uploading the files.

The options menu has a button to start a "purge". This will get rid of files in the cloud that aren't present on the drive. This effectively saves space, resulting in lower cost by not storing useless files.
Note that purging does not immediately remove the files, it "hides" them, meaning what exactly happens depends on your lifecycle rules. See here for details.

Setup

You'll need to do a bit of setup in Backblaze before you can use this program.
First you should create a bucket, then you should generate a new app key. It it suggested that you change the lifecycle settings of the bucket to " Keep prior versions for this number of days".

You'll need to generate a new application key. Go into 'App Keys' and press 'Add a New Application Key'

You can give the key a name and optionally make it only work for your new bucket and more.

Now you're presented with the app key secret:
Note that the 'applicationKey' will only be shown once. If you lose it, you need to make a new key.

Lastly you need to grab the ID of the bucket you created, which can be read in the menu:

Disclaimer

This project is not associated with Backblaze. Use at your own risk. See License.md.

Download Details:
Author: KongouDesu
Source Code: https://github.com/KongouDesu/BackupGUI
License: MIT license

#rust #applications

Viewimg | OpenEXR and Radiance HDR Image Viewer Written in Rust

viewimg 

viewimg is an image viewer intended to be used with OpenEXR and Radiance HDR images, however other popular image formats are supported as well. The goal of viewimg is to be a cross-platform image viewer that quickly opens OpenEXR and Radiance HDR images with the purpose of instantly seeing the image contents. There is no editing component to this application, therefore tone mapping and other HDR editing operators are not supported. The typical use case of viewimg would be to view HDR images immediately after rendering.

For both OpenEXR and Radiance HDR images, the f32 values are intensity corrected prior to casting to u8. In the case of OpenEXR images, gamma correction of 2.0 is also applied.

Installation

To install viewimg run cargo install viewimg in a terminal prompt.

Note: Vulkan must be installed on the target system in order for viewimg to work correctly. For Debian users this can be done with the command sudo apt install mesa-vulkan-drivers.

Usage

To use viewimg you can run viewimg in a terminal with the path to the image file that you wish to open:

$  viewimg ../cornell_box_denoised.hdr

Screenshot

Download Details:
Author: mandeep
Source Code: https://github.com/mandeep/viewimg
License:

#rust #applications

Rawrscope | High Performance Oscilloscope Generation Written in Rust

rawrscope

rawrscope is a fast, user-friendly, and cross-platform tool for creating oscilloscope visualizations of audio, typically chiptune.

Build Status

TODO: somehow have separate badges for each os

Features

* = unimplemented

• *Intuitive interface
• Realtime editor and preview
• Antialiased, GPU accelerated line rendering
• Many centering algorithms
  • Zero Crossing
  • *Peak Speed
  • Fundamental Phase
  • *External Trigger
• *High-quality trigger generator for external trigger mode
• Audio manipulation tools (*trim, fade in/out)
• *Node-based audio routing interface
  • Automatic master audio generation
  • Stereo upmixing/downmixing
• *Visual templates and presets for a quicker workflow
• *Built-in video export
• *Arbitrary post-processing shaders
• *Command line interface
• Written in Rust :)

Installation

From CI

View the CI runs here, select the latest successful run, and download the appropriate ZIP file from the "Artifacts" tab in the top right. Then, just extract the archive.

From source

Clone the repository and run cargo build --release.

CMake, Ninja, and Python are required for building dependencies.

Note: The dev profile still has optimizations enabled, if you would like to skip optimizations, build with the test profile

Tutorial

TODO

Contributing

Any help resolving issues is appreciated, issues tagged X=help needed are likely a good place to start. If coding isn't your thing, then issues tagged X=feedback wanted could still use your help.

All code contributed should be formatted with rustfmt before being merged.

rawrscope is licenced under GPLv3+, see COPYING for details.

Future Roadmap

• Multi-song projects

Download Details:
Author: chiptunecafe
Source Code:  https://github.com/chiptunecafe/rawrscope
License: GPL-3.0 license

#rust #applications

Sailor | A Sailing Navigation Application Written in Rust

Sailor

A sailing navigation application.

Building

Building for vulkan & Linux/Windows

cargo build --verbose --bin sailor

Building for metal & macOS

cargo build --verbose --bin sailor --no-default-features --features metal

Download Details:
Author: Yatekii
Source Code: https://github.com/Yatekii/sailor
License:

#rust #applications

La Diferencia Entre IPaaS Y ESB

Según un informe de IDC , se espera que las inversiones en servicios de nube pública crezcan a 203 400 millones de dólares en todo el mundo, con una CAGR del 21,5 %. La abrumadora velocidad a la que las empresas están adoptando servicios en la nube está creando un desafío de integración para las empresas que utilizan sistemas de integración locales más antiguos, como los ESB, cuyos sistemas no fueron diseñados para manejar la integración en la nube.

Como respuesta, las empresas están recurriendo a herramientas y soluciones de  integración como la plataforma de integración como servicio (iPaaS) para complementar las debilidades de sus instalaciones de  bus de servicios empresariales (ESB) existentes.

Pero, ¿cuáles son exactamente las diferencias entre iPaaS y ESB? ¿Cuándo debería una empresa usar iPaaS? ¿Qué hay de ESB? En esta publicación, arrojamos algo de luz sobre las diferencias entre estas dos herramientas de integración.

iPaaS frente a ESB: una descripción general

iPaaS y ESB tienen el mismo propósito principal: la integración de sistemas y aplicaciones empresariales. La principal diferencia entre iPaaS y ESB radica en el tipo de sistemas que integran mejor, el nivel de complejidad de sus integraciones y su escalabilidad.

Tipo de sistema

Generalmente, iPaaS y ESB están en extremos opuestos del continuo. iPaaS es un conjunto de herramientas de integración proporcionadas desde una nube pública y no requiere hardware o software local. iPaaS fue diseñado específicamente para manejar los estándares de documentos y mensajes livianos (REST, JSON, etc.) que utilizan las aplicaciones en la nube de hoy.

ESB, por otro lado, es un modelo de arquitectura de software local que generalmente utiliza tecnología común antes del surgimiento de la nube. Como tal, su gran huella local y los estándares de documentos y mensajes más antiguos funcionan mejor para integrar sistemas locales y agregados como SAP.

Sin embargo, estos dos modelos de integración están viendo venir la convergencia; algunas soluciones iPaaS han evolucionado para admitir sistemas locales, mientras que algunos proveedores de ESB han introducido funciones para admitir de manera más elegante la integración de servicios en la nube.

Complejidad

ESB está diseñado para integrar arquitectura y sistemas de TI complejos. Mantiene unidos los sistemas locales y heredados de una empresa. iPaaS, por otro lado, ofrece una solución de integración más liviana y más adecuada para aplicaciones flexibles y en tiempo real, que son requisitos críticos de los servicios basados ​​en la nube.

Escalabilidad

Finalmente, un punto importante de diferencia entre iPaaS y ESB es la dirección de la escalabilidad. ESB es el más adecuado para la escalabilidad vertical: la integración de la arquitectura y los sistemas internos complejos de una empresa. Esto tiene sentido si se considera la evolución del ESB, que llegó a la mayoría de edad hace más de una década, cuando los sistemas de planificación de recursos empresariales (ERP) eran los pesos pesados ​​del software empresarial. Por otro lado, iPaaS es más adecuado para la escalabilidad horizontal: integración con terceros, socios y aplicaciones ad hoc, como soluciones de software como servicio (SaaS). Ligero y flexible, iPaaS permite a las empresas conectarse e integrar rápidamente sus aplicaciones y sistemas en la nube.

Profundizando: otras diferencias y casos de uso de iPaaS

Aparte de estas diferencias principales, hay otros factores que diferencian iPaas y ESB, como la multitenencia. Comprender los casos de uso de iPaaS también puede ayudar a contrastar aún más las dos tecnologías.

Arquitectura multiusuario

Una arquitectura de múltiples inquilinos se refiere a una sola instancia de software que se ejecuta en un solo servidor mientras atiende a múltiples grupos de usuarios. Por ejemplo, un único software que atiende a diferentes personas o departamentos, como finanzas, marketing y operaciones, opera en una arquitectura de múltiples inquilinos. Debido a su complejidad inherente, la mayoría de las soluciones ESB no son multiusuario.

Por otro lado, iPaaS admite multiusuario. Esto le da a las soluciones iPaaS una ventaja sobre ESB, ya que múltiples inquilinos o usuarios pueden compartir una sola instancia para reducir efectivamente las redundancias en los procesos de integración. La tenencia múltiple también puede reducir los costos administrativos y de infraestructura durante la integración.

Integración ad hoc

Tradicionalmente, las iniciativas de software y aplicaciones las lleva a cabo el departamento de TI de una empresa. Sin embargo, cada vez más departamentos están autorizados para comprar, instalar y utilizar su propio software de forma ad hoc, especialmente ahora que las soluciones SaaS hacen posible que las aplicaciones se incluyan en los gastos operativos de un departamento en lugar de sus gastos de capital. Las soluciones ad hoc requieren una integración flexible, ligera y en tiempo real.

ESB es demasiado lento y complejo para proyectos de integración ad hoc. Requiere la experiencia de los departamentos de TI, lo que anula el propósito de las iniciativas de aplicaciones ad hoc y ralentiza la entrega de proyectos. La simplicidad, la flexibilidad y las capacidades en tiempo real de las soluciones iPaaS ayudan a satisfacer las demandas aceleradas de las integraciones ad hoc y ayudan a otros departamentos auxiliares a lograr sus objetivos comerciales de manera eficiente sin verse frenados por la complejidad de ESB.

Integración SaaS

Hoy, tanto iPaaS como ESB pueden integrar soluciones SaaS con sistemas heredados y locales. iPaaS utiliza inherentemente conectores ligeros como JSON y API, que son los más adecuados para la integración de SaaS, mientras que hay un número creciente de soluciones ESB que pueden utilizar los mismos protocolos de servicios web ligeros. Los expertos llaman a estas tecnologías de integración ESB ligeros o ESB en la nube. Sin embargo, el ESB tradicional utiliza tecnologías de middleware más complejas, como la arquitectura de middleware orientado a mensajes (MOM), que no utilizan las soluciones SaaS.

Integración IoT

Además de SaaS, otra tendencia emergente es el auge de los dispositivos habilitados para Internet o Internet de las cosas (IoT). La integración de IoT requiere una escalabilidad horizontal significativamente alta debido al gran volumen de dispositivos conectados, la conectividad liviana y la baja latencia requerida para un rendimiento óptimo. Además de estos requisitos, la integración de IoT también exige una conexión en tiempo real. Estos factores hacen que ESB no sea adecuado para este tipo de integración. Además, la integración de IoT también requiere integración externa. Juntando todos estos factores, es fácil concluir que la mejor solución de integración para IoT es iPaaS.

Tecnologías complementarias, no competidoras

A pesar de sus aparentemente abrumadoras ventajas sobre ESB, iPaaS todavía tiene sus limitaciones. Todavía no es práctico ni rentable utilizar iPaaS para empresas con sistemas organizativos complejos y arquitecturas internas. ESB sigue siendo el pegamento preferido para mantener unidos los sistemas internos. Por esta razón, las empresas suelen utilizar iPaaS y ESB al mismo tiempo para mantener juntos su arquitectura interna y sus sistemas heredados, al tiempo que se adaptan a nuevos puntos finales de integración, como SaaS, servicios en la nube y dispositivos IoT.

Fuente del artículo original en: https://dzone.com/articles/ipaas-vs-esb-understanding-the-difference

#ipaas  #esb #saas #iot #applications #webservice 

iPaaSとESBの違いは正確には何ですか？

IDCのレポートによると、パブリッククラウドサービスへの投資は、21.5％のCAGRで、世界全体で2,034億ドルに成長すると予想されています。企業がクラウドサービスを採用している圧倒的な速度は、システムがクラウド統合を処理するように設計されていないESBなどの古いオンプレミス統合システムを使用している企業にとって統合の課題を生み出しています。

 その対応として、企業は、既存のエンタープライズサービスバス（ESB）インストールの弱点を補うために 、Integration Platform as a Service（iPaaS）などの統合ツールやソリューションに目を向けています。

しかし、iPaaSとESBの違いは正確には何ですか？企業はいつiPaaSを使用する必要がありますか？ESBはどうですか？この投稿では、これら2つの統合ツールの違いに光を当てます。

iPaaSとESB：概要

iPaaSとESBは、エンタープライズシステムとアプリケーションの統合という同じ主な目的を果たします。iPaaSとESBの主な違いは、それらが最もよく統合するシステムの種類、それらの統合の複雑さのレベル、およびそれらのスケーラビリティにあります。

システムタイプ

一般的に、iPaaSとESBは連続体の反対側にあります。iPaaSは、パブリッククラウドから提供される統合ツールのセットであり、オンプレミスのハードウェアやソフトウェアを必要としません。iPaaSは、今日のクラウドアプリで使用されている軽量のメッセージングおよびドキュメント標準（REST、JSONなど）を処理するように特別に設計されています。

一方、ESBはオンプレミスのソフトウェアアーキテクチャモデルであり、通常、クラウドが登場する前に一般的なテクノロジーを利用します。そのため、オンプレミスのフットプリントが大きく、古いメッセージングおよびドキュメント標準は、オンプレミスとSAPなどの集約システムを統合するのに最適です。

ただし、これら2つの統合モデルは収束しつつあります。一部のiPaaSソリューションは、オンプレミスシステムをサポートするように進化しましたが、一部のESBベンダーは、クラウドサービスの統合をよりエレガントにサポートする機能を導入しました。

複雑

ESBは、複雑なITシステムとアーキテクチャを統合するように設計されています。これは、企業のオンプレミスシステムとレガシーシステムをまとめたものです。一方、iPaaSは、クラウドベースのサービスの重要な要件である柔軟でリアルタイムのアプリケーションにより適した、より軽量な統合ソリューションを提供します。

スケーラビリティ

最後に、iPaaSとESBの主な違いは、スケーラビリティの方向性です。ESBは、企業の複雑な内部システムとアーキテクチャの統合である垂直スケーラビリティに最適です。これは、エンタープライズリソースプランニング（ERP）システムがエンタープライズソフトウェアの大物であった10年以上前に成熟したESBの進化を考えると理にかなっています。一方、iPaaSは、サードパーティ、パートナー、およびSoftware as a Service（SaaS）ソリューションなどのアドホックアプリケーションとの統合という、水平方向のスケーラビリティに適しています。軽量で柔軟性のあるiPaaSにより、企業はクラウドアプリケーションとシステムをすばやく接続して統合できます。

さらに深く：iPaaSの他の違いとユースケース

これらの主な違いの他に、マルチテナンシーなど、iPaasとESBを区別する他の要因があります。iPaaSのユースケースを理解することも、2つのテクノロジーをさらに対比するのに役立ちます。

マルチテナントアーキテクチャ

マルチテナントアーキテクチャとは、複数のユーザーグループにサービスを提供しながら、単一のサーバーで実行されるソフトウェアの単一のインスタンスを指します。たとえば、財務、マーケティング、運用など、さまざまな個人や部門に対応する単一のソフトウェアは、マルチテナントアーキテクチャで動作します。固有の複雑さのため、ほとんどのESBソリューションはマルチテナントではありません。

一方、iPaaSはマルチテナンシーをサポートしています。これにより、iPaaSソリューションはESBよりも有利になります。これは、複数のテナントまたはユーザーが単一のインスタンスを共有して、統合プロセスの冗長性を効果的に削減できるためです。マルチテナンシーは、統合中のインフラストラクチャと管理コストも削減できます。

アドホック統合

従来、ソフトウェアとアプリケーションのイニシアチブは、企業のIT部門によって実行されていました。ただし、今日、ますます多くの部門がアドホックベースで独自のソフトウェアを購入、インストール、および利用できるようになっています。特に、SaaSソリューションにより、アプリケーションが資本的支出ではなく部門の営業費用に分類されるようになっています。アドホックソリューションには、柔軟で軽量なリアルタイムの統合が必要です。

ESBは、アドホック統合プロジェクトには遅すぎて複雑です。IT部門の専門知識が必要であり、アドホックアプリケーションイニシアチブの目的を無効にし、プロジェクトの提供を遅らせます。iPaaSソリューションのシンプルさ、柔軟性、およびリアルタイム機能は、アドホック統合のペースの速い要求に対応し、他の補助部門がESBの複雑さにとらわれることなくビジネス目標を効率的に達成するのに役立ちます。

SaaS統合

現在、iPaaSとESBはどちらも、SaaSソリューションをオンプレミスおよびレガシーシステムと統合できます。iPaaSは本質的にSaaS統合に最適なJSONやAPIなどの軽量コネクタを使用しますが、同じ軽量Webサービスプロトコルを利用できるESBソリューションの数は増え続けています。専門家は、これらの統合テクノロジーを軽量ESBまたはクラウドESBと呼んでいます。ただし、従来のESBは、SaaSソリューションでは使用されないメッセージ指向ミドルウェア（MOM）アーキテクチャなどのより複雑なミドルウェアテクノロジを使用します。

IoT統合

SaaSに加えて、もう1つの新しいトレンドは、インターネット対応デバイスまたはモノのインターネット（IoT）の台頭です。IoT統合には、接続されたデバイスの膨大な量、軽量の接続、および最適なパフォーマンスに必要な低遅延のために、非常に高い水平スケーラビリティが必要です。これらの要件とは別に、IoT統合にはリアルタイム接続も必要です。これらの要因により、ESBはこの種の統合にはあまり適していません。さらに、IoT統合には外部統合も必要です。これらすべての要素を総合すると、IoTのより優れた統合ソリューションはiPaaSであると簡単に結論付けることができます。

補完する、競合しないテクノロジー

ESBに比べて一見圧倒的な利点があるように見えますが、iPaaSにはまだ制限があります。複雑な組織システムと内部アーキテクチャを備えた企業にiPaaSを利用することは、まだ実用的でなく、費用対効果も高くありません。ESBは、内部システムをまとめるための好ましい接着剤です。このため、iPaaSとESBは、SaaS、クラウドサービス、IoTデバイスなどの新しい統合エンドポイントに対応しながら、内部アーキテクチャとレガシーシステムをまとめるために企業によって同時に利用されることがよくあります。

元の記事のソース：https ：//dzone.com/articles/ipaas-vs-esb-understanding-the-difference

#ipaas  #esb #saas #iot #applications #webservice 

How to Create A Library Of Favorite Podcasts

My Podcast Library

Tier: 3-Advanced

In the GitHub Status and Podcast Directory you learned what web scraping is and how you can use it as an alternative data source when API's and backend databases aren't available. The My Podcast Library app merges your newfound knowledge of web scraping with your frontend skills to extend the simple Podcast Directory app into something more complex and useful.

The goal of My Podcast Library is to build a more personalized library of your favorite podcasts and episodes. In this app you'll use Puppeteer and Podbean to create an app to maintain your personal library of podcasts.

This project is described in detail by the following user stories, but feel free to use your imagination.

User Stories

Favorite Podcast Display

•  User can see their favorite podcasts in a tabular display area
•  User can see the message 'No podcasts added yet' in watermark format in this area if no podcasts have been added.
•  User can see an overview of each favorite podcast that has been added in this area. This includes the podcast icon, it's name, and the number of most recent episodes.
•  User can click on the podcast icon to display a page containing a list of the most recent episodes.

Favorite Podcast Entry

•  User can see a '+' button at the top of the favorite podcast area with the hover text 'Add a new podcast'
•  User can click the '+' button to display a popup panel to allow a new favorite podcast added. This panel contains an input area containing a text input box for the podcasts page on Podbean (e.g. Techpoint Charlie), a 'Save' button, and a 'Cancel' button.
•  User can click the 'Save' button to validate the URL and add the podcast to the favorite podcast area.
•  User can see a warning message if the url doesn't start with https://www.podbean.com/podcast-detail/ or if navigating to the page results in a 404 error.
•  User can see valid URLs for favorite podcasts retained across sessions.
•  User can click the 'Cancel' button to discard any data and dismiss the popup.

Most Recent Episodes for a Podcast Page

•  User can see a table of podcast episodes
•  User can see rows in this table showing a clickable episode icon, the title of the episode, the date it was originally broadcast, and a heart icon button to mark it as a favorite.
•  User can scroll through the list
•  User can click on the episode icon to display that episodes page on the Podbean web site.
•  User can click on an episode's heart icon to mark it as a favorite.
•  User can click on an episode's heart icon to remove it as a favorite.
•  User can see the table sorted with most recent episodes at the top, followed by those previously marked as favorites.
•  User can see favorite episodes persist across sessions.

Bonus features

Episode Ratings

•  User can see 5 star icons with each episode that denotes how the user rates it.
•  User may click stars from left-to-right to rate an episode. Stars are filled or changed to a new color when clicked.
•  User may change a rating by clicking on the stars from right-to-left to deselect them.
•  User can see the list of favorite episodes on the page sorted in descending rating sequence.

Searching & Hashtags

•  User can enter a freeform hashtag with an episode on the most recent episodes page. This hashtag does not need to be predefined.
•  User can see a search box on the main page and a 'Search' button
•  User can enter hashtags in the search box to display a page of episodes from any podcast with the same format as the most recent episodes page.
•  User can click on a cancel button on the search results page to return to the main page.

Useful links and resources

• Puppeteer
• Web Scraping with a Headless Browser: A Puppeteer Tutorial
• querySelectorAll

Example projects

N/a

Github: https://github.com/florinpop17/app-ideas/blob/master/Projects/3-Advanced/MyPodcast-Library-app.md

#applications  #mobileapp 

How to Create Instagram Clones (Advanced)

Instagram Clone

Tier: 3-Advanced

A clone of Facebook's Instagram app where you can login/register, create new posts, follow other users and see other people you follows posts

You should create a MVP (Minimum Viable Product) using a Full stack approach such as the MEAN, MERN or VENM Stack to store images to the server and display them to the client.

User Stories

•  User can register for an account storing their name, email/username and password then login to the app using their credentials
•  User can create a post and store images to the server (Preferably in a database)
•  User has a profile that displays all the images they have uploaded
•  User can follow other users
•  User can see other users posts (people who the user follows)

Bonus features

•  User can see a global feed of images
•  The feed auth refreshes when a new post is added (You can use Web Sockets)
•  User can send messages to other users
•  User can create a story for followers

Useful links and resources

• How to make an Instagram clone
• Node & Mongo Basic CRUD Operations
• Socket.io
• MERN Stack
• MEAN Stack
• User Authentication with Node
• Express File Uploads with Multer

Example projects

• Instagram

Github: https://github.com/florinpop17/app-ideas/blob/master/Projects/3-Advanced/Instagram-Clone-App.md

#applications #instagram  #mobileapp 

Notes App: Create an online Note Pad

Notes App

Tier: 1-Beginner

Create and store your notes for later purpose!

User Stories

•  User can create a note
•  User can edit a note
•  User can delete a note
•  When closing the browser window the notes will be stored and when the User returns, the data will be retrieved

Bonus features

•  User can create and edit a note in Markdown format. On save it will convert Markdown to HTML
•  User can see the date when he created the note

Useful links and resources

• localStorage
• Markdown Guide
• Marked - A markdown parser

Example projects

• Markdown Notes built with Angular on Codepen
• Markdown Notes built with React
• Markdown Notes built with Angular 7 and bootstrap 4

Github: https://github.com/florinpop17/app-ideas/blob/master/Projects/1-Beginner/Notes-App.md

#applications  #mobileapp 

Key Value: Display The Encoded Value on Screen

Key Value

Tier: 1-Beginner

Have you ever thought about what it means that the computer you are using is a digital device? Among other things it means that everything its capable of is achieved by translating a digital signal into a sequence of binary digits - 0's and 1's. These binary digits form codes used to represent data.

The keyboard you used to retrieve this project description is a great example of this. Pressing a key generates a digital signal that is translated by the computer into a code representing the key that was pressed.

The goal of the Key Value app is to display the encoded value on screen each time a key is pressed on the keyboard.

User Stories

•  User can see a display panel containing a text area where the key value and key code will be displayed along with display areas for four other indicators related to the keys on the keyboard - alt key, control key, meta key, and shift key.
•  User can see the key code and key value displayed in the display panel corresponding to the key when it is pressed.
•  User can see the appropriate indicator change from 'False' to 'True' when the alt, control, meta, or shift key is pressed.

Bonus features

•  User can hear a unique tone played when a key is pressed.
•  User can see the background color of the key code and value change when a key is pressed.

Useful links and resources

• Digital Electronics
• Keyboard Event

Example projects

Javascript Keyevent Test Script

Github: https://github.com/florinpop17/app-ideas/blob/master/Projects/1-Beginner/Key-Value-App.md

#applications #javascript  #mobileapp 

Javascript Validation With Regex

Tier: 1-Beginner

In this challenge, you'd create a javascript validation script to validate the inputs entered by a user using RegEx.

You could always refer to the Regular Expression Library for support

For this project, there'd be three required inputs for validation:

• The first would require the user to enter five (5) capital letters, six (6) symbols and two hyphens (-) in any order. This could be used as a password.
• The second which could be used as username would require the user to enter letters without spaces
• The third which could be used as email address would require the user to enter only email addresses on gmail (...@gmail.com).

User Stories

•  User should be notified of any invalid inputs by error messages displayed on the form.
•  The submit button on the form would never be executed until all entries are validated.

Useful links and resources

• Javascript form validation using regular expressions
• JavaScript Form Validation Using Regular Expressions

Example project

• Native HTML5 validation with CSS & Regex

Github: https://github.com/florinpop17/app-ideas/blob/master/Projects/1-Beginner/Javascript-Validation-With-Regex.md

#applications  #mobileapp #javascript 

Hello App: User Native Language Greeting

Hello

Tier: 1-Beginner

It is a given that applications must provide users with the functionality necessary to accomplish some task or goal. The effectiveness of app functionality is the first determinate of how users perceive the apps they use. However, it is not the only thing that influences user satisfaction.

The User Interface and User Experience (UI/UX) features developers build into apps have at least an equal amount of influence on users perception of an app. It may be an oversimplification, but UI/UX is largely (but not wholly) concerned with an apps "form". Personalization is an aspect of UX that tailors characteristics and actions to the individual user. Personalizing app functionality in this manner works to make the app easier and more pleasing to use.

The objective of the Hello app is to leverage geolocation to obtain the users country so it can then generate a customized greeting in the users native language.

Constraints

• Developers should use the IP-API service to obtain the users IP.
• Developers should use the Fourtonfish service to obtain the greeting in the users native language by passing the users IP.
• Developers must use a HTML entities decoding to decode the hello message.

User Stories

•  User can see a mock login panel containing a user name text input field, a password text input field, and 'Login' and 'Logout' buttons.
•  User can enter a mock login name into the User Name field.
•  User can enter a mock password into the Password field. Input should be masked so the user see's asterisks (*) for each character that is entered rather than the plaintext password.
•  User can click the 'Login' button to perform a mock login.
•  User can see a message if either or both of the input fields are empty and the border color of the field(s) in error should be changed to red.
•  User can see a login acknowledgement message in the format: <hello-in-native-language> <user-name> you have successfully logged in!
•  User can click the 'Logout' button to clear the text input fields and any previous messages.
•  User can see a new message when successfully logged out in the format: Have a great day <user-name>!

Bonus features

•  User can see an additional text input field for a language code which will be used to override the IP obtained through geolocation. Hint: this is a great feature for testing your app.
•  User can see additional geolocation information after logging on that includes at least the local IP address, city, region, country name, zip code, longitude, latitude, and timezone.

Useful links and resources

• Form Follows Function (Wikipedia)
• Personalization (Wikipedia)
• Fourtonfish
• IP-API

Example projects

Fourtonfish Hello World

Github: https://github.com/florinpop17/app-ideas/blob/master/Projects/1-Beginner/Hello-App.md

#applications  #mobileapp #ui #ux 

How to Display Current GitHub Status

GitHub Status

Tier: 1-Beginner

Web apps acquire data in many ways. Through user input in web pages, through API's to backend systems, from files and databases, and sometimes by "scraping" websites. The objective of the GitHub Status app is to introduce you to one way to scrape information from another web site.

GitHub Status uses the NPM Request package to retrieve the current GitHub site status from the GitHub Status web site. The Request package allows websites to be retrieved not to a browser window, but as a JSON document that can be readily accessed by your code.

Although this application specification relies heavily on Javascript, feel free to develop it using your language of choice!

User Stories

•  User can see the current status for GitHub Git operations, API Requests, Operational Issues, PRs, Dashboard, & Projects, Operational Notifications, Operational Gists, and Operational GitHub Pages as a list in the main app window.
•  User can retrieve the most recent status from the GitHub Status web site by clicking a 'Get Status' button.

Bonus features

•  User can see any of the GitHub components that are not in 'Operational' status highlighted by a different color, background animation, or any other technique to make it stand out. Use your imagination!

Useful links and resources

• Web Scraping (Wikipedia)
• NPM Request
• Javascript JSON (MDN)
• Javascript Object Notation
• Hint! You can use the following code to display the JSON for the GitHub Status web site page from the command line command node ghstatus. You can use this output to determine which JSON element contain the status information you'll need to develop this app.

ghstatus.js

const request = require('request');
request('https://www.githubstatus.com/',  { json: true }, (err, res, body) => {  
    console.log(body);
});

Example projects

• Peter Luczynski's example
• Diogo Moreira's example

Github: https://github.com/florinpop17/app-ideas/blob/master/Projects/1-Beginner/GitHub-Status-App.md

#applications  #mobileapp #github