TapConnect

tapconnect

Ockam Routing: Building End-to-End Channels

Enrutamiento Ockam: creación de canales seguros de extremo a extremo

Routage Ockam : création de canaux sécurisés de bout en bout

ओकाम रूटिंग: सुरक्षित एंड-टू-एंड चैनल बनाना

Ockam ルーティング: 安全なエンドツーエンド チャネルの構築

Roteamento Ockam: Construindo Canais Seguros de Ponta a Ponta

Ockam Routing: Xây dựng các kênh đầu cuối an toàn

Ockam Routing：构建安全的端到端通道

Decoding Network Traffic: The Vital Role of Telemetry in Understanding Network Activity

Bucharest-based startup The Connecter hits $1.2M post-money valuation after its recent backing by two prominent venture capital firms: Startupbootcamp and Hatcher+. Startupbootcamp, Europe's leading accelerator with a $5.6 billion portfolio valuation, selected The Connecter as one of the top 10 out of 1.8k applicants for their sustainable fintech program. This recognition speaks volumes about The Connecter's potential to disrupt and innovate within the fintech space. Moreover, Hatcher+, based out of Singapore, joined the funding round, bringing with them the expertise of the H2 Fund. This early-stage venture specializes in licensing AI-powered portfolio construction technologies to build sector-agnostic, diversified portfolios capable of generating robust, predictable returns for investors. In today's interconnected world, access to financial services is not just a luxury but a necessity. Yet, over 1.7 billion people still lack access to basic financial tools, facing daunting challenges like international transactions, currency devaluation, and custodian risks. While decentralized finance (DeFi) promises solutions, its current complexities leave many on the sidelines, with a staggering 70% unable to navigate account openings error-free without assistance. Additionally, a significant 50% of user transactions end in failure. A Vision of Inclusion: The Connecter's Approach Enter The Connecter, a decentralized finance super app on a mission to democratize access to wealth and bring the benefits of DeFi mainstream. The Connecter is designed for the everyday person, offering a seamless blend of Web 2 fintech ease with a Web 3 backend. Its vision? To grant users full asset ownership, stable currencies, heightened security, and global reach. “The Connecter is really about connection in every way. It’s connecting existing technologies to form greater ones, it’s connecting people to form novel experiences, and it’s connecting people to freedom. There exists so many issues when it comes down to our prevailing economic systems that are currently in place. Firstly, the amount of money people have to pay simply to have a safe place to put their money, and then again to actually use it. Secondly, the little accessibility people essentially have to their own hard earned money. And thirdly, the several privacy breaches that occur in centralized, regulated economic systems. The Connecter addresses and provides solutions to all of these problems, enabling individuals to have autonomy, accessibility and utilization over their own hard-earned finances. When I envision the potential of The Connecter, I see it really changing the way we as humans interact and perceive the reality in which we currently operate in. I see The Connecter eliminating corruption, increasing individual freedom, and giving power back to people. I see The Connecter changing the world for the better at it’s most fundamental level.” - Paige Soponar, COO and Co-Founder of The Connecter User-Centric Design: The Connecter's Differentiator At the heart of The Connecter's success lies its user-centric approach, backed by evidence-based UI expertise from their R&D department, closely affiliated with Asia Pacific YNBC. With a co-founder specializing in the psychology of technological mass adoption, The Connecter ensures a frictionless onboarding experience that is particularly crucial for newcomers to the crypto and DeFi realm. Setting New Standards: The Connecter's Features What sets The Connecter apart from its competitors is its commitment to real-world assets (RWA) and utility, operating within a B2B2C framework. Moreover, it boasts true global accessibility, with support for over 130 different payment options, including major cards like Mastercard and Visa, as well as popular platforms like Revolut and Western Union. The Connecter's payment aggregator significantly boosts transaction success rates by an impressive 80% while consistently offering clients the lowest fees in the market. “The Connecter’s promise represents more than just a DeFi solution. It embodies a movement towards financial inclusion and empowerment, fueled by cutting-edge technology and backed by top-tier investors. As The Connecter continues to pave the way towards a more accessible and democratized financial future, it stands poised to revolutionize the way we interact with and understand finance.” - Eduard Soponar, CEO & Co-Founder The Connecter. www.theconnecter.io This story was distributed under HackerNoon’s Brand As An Author Program. Learn more about the program here. Bucharest-based startup The Connecter hits $1.2M post-money valuation after its recent backing by two prominent venture capital firms: Startupbootcamp and Hatcher+. Startupbootcamp, Europe's leading accelerator with a $5.6 billion portfolio valuation, selected The Connecter as one of the top 10 out of 1.8k applicants for their sustainable fintech program. This recognition speaks volumes about The Connecter's potential to disrupt and innovate within the fintech space. Moreover, Hatcher+, based out of Singapore, joined the funding round, bringing with them the expertise of the H2 Fund. This early-stage venture specializes in licensing AI-powered portfolio construction technologies to build sector-agnostic, diversified portfolios capable of generating robust, predictable returns for investors. In today's interconnected world, access to financial services is not just a luxury but a necessity. Yet, over 1.7 billion people still lack access to basic financial tools, facing daunting challenges like international transactions, currency devaluation, and custodian risks. While decentralized finance (DeFi) promises solutions, its current complexities leave many on the sidelines, with a staggering 70% unable to navigate account openings error-free without assistance. Additionally, a significant 50% of user transactions end in failure. A Vision of Inclusion: The Connecter's Approach A Vision of Inclusion: The Connecter's Approach Enter The Connecter, a decentralized finance super app on a mission to democratize access to wealth and bring the benefits of DeFi mainstream. The Connecter is designed for the everyday person, offering a seamless blend of Web 2 fintech ease with a Web 3 backend. Its vision? To grant users full asset ownership, stable currencies, heightened security, and global reach. “ The Connecter is really about connection in every way. It’s connecting existing technologies to form greater ones, it’s connecting people to form novel experiences, and it’s connecting people to freedom. There exists so many issues when it comes down to our prevailing economic systems that are currently in place. Firstly, the amount of money people have to pay simply to have a safe place to put their money, and then again to actually use it. Secondly, the little accessibility people essentially have to their own hard earned money. And thirdly, the several privacy breaches that occur in centralized, regulated economic systems. The Connecter addresses and provides solutions to all of these problems, enabling individuals to have autonomy, accessibility and utilization over their own hard-earned finances. When I envision the potential of The Connecter, I see it really changing the way we as humans interact and perceive the reality in which we currently operate in. I see The Connecter eliminating corruption, increasing individual freedom, and giving power back to people. I see The Connecter changing the world for the better at it’s most fundamental level. ” - Paige Soponar, COO and Co-Founder of The Connecter The Connecter is really about connection in every way. It’s connecting existing technologies to form greater ones, it’s connecting people to form novel experiences, and it’s connecting people to freedom. There exists so many issues when it comes down to our prevailing economic systems that are currently in place. Firstly, the amount of money people have to pay simply to have a safe place to put their money, and then again to actually use it. Secondly, the little accessibility people essentially have to their own hard earned money. And thirdly, the several privacy breaches that occur in centralized, regulated economic systems. The Connecter addresses and provides solutions to all of these problems, enabling individuals to have autonomy, accessibility and utilization over their own hard-earned finances. When I envision the potential of The Connecter, I see it really changing the way we as humans interact and perceive the reality in which we currently operate in. I see The Connecter eliminating corruption, increasing individual freedom, and giving power back to people. I see The Connecter changing the world for the better at it’s most fundamental level. User-Centric Design: The Connecter's Differentiator User-Centric Design: The Connecter's Differentiator At the heart of The Connecter's success lies its user-centric approach, backed by evidence-based UI expertise from their R&D department, closely affiliated with Asia Pacific YNBC. With a co-founder specializing in the psychology of technological mass adoption, The Connecter ensures a frictionless onboarding experience that is particularly crucial for newcomers to the crypto and DeFi realm. Setting New Standards: The Connecter's Features Setting New Standards: The Connecter's Features What sets The Connecter apart from its competitors is its commitment to real-world assets (RWA) and utility, operating within a B2B2C framework. Moreover, it boasts true global accessibility, with support for over 130 different payment options, including major cards like Mastercard and Visa, as well as popular platforms like Revolut and Western Union. The Connecter's payment aggregator significantly boosts transaction success rates by an impressive 80% while consistently offering clients the lowest fees in the market. “ The Connecter’s promise represents more than just a DeFi solution. It embodies a movement towards financial inclusion and empowerment, fueled by cutting-edge technology and backed by top-tier investors. As The Connecter continues to pave the way towards a more accessible and democratized financial future, it stands poised to revolutionize the way we interact with and understand finance. ” - Eduard Soponar, CEO & Co-Founder The Connecter. The Connecter’s promise represents more than just a DeFi solution. It embodies a movement towards financial inclusion and empowerment, fueled by cutting-edge technology and backed by top-tier investors. As The Connecter continues to pave the way towards a more accessible and democratized financial future, it stands poised to revolutionize the way we interact with and understand finance. www.theconnecter.io www.theconnecter.io This story was distributed under HackerNoon’s Brand As An Author Program. Learn more about the program here. This story was distributed under HackerNoon’s Brand As An Author Program. Learn more about the program here. This story was distributed under HackerNoon’s Brand As An Author Program. Learn more about the program here . here

Romanian Startup The Connecter secures pre-seed round led by Hatcher+ & Startupbootcamp Australia 

রোমানিয়ান স্টার্টআপ দ্য কানেটার হ্যাচার+ এবং স্টার্টআপবুটক্যাম্প অস্ট্রেলিয়ার নেতৃত্বে প্রি-সিড রাউন্ড সুরক্ষিত করে

Rumänisches Startup The Connecter sichert sich Pre-Seed-Runde unter der Leitung von Hatcher+ und Startupbootcamp Australia

La startup rumana The Connecter asegura una ronda previa a la semilla liderada por Hatcher+ y Startupbootcamp Australia

La start-up roumaine The Connecter remporte un cycle de pré-amorçage dirigé par Hatcher+ et Startupbootcamp Australia

रोमानियाई स्टार्टअप द कनेक्टर ने हैचर+ और स्टार्टअपबूटकैंप ऑस्ट्रेलिया के नेतृत्व में प्री-सीड राउंड हासिल किया

ルーマニアのスタートアップ The Connecter が Hatcher+ と Startupbootcamp Australia が主導するプレシードラウンドを獲得

루마니아 스타트업 The Connecter, Hatcher+ 및 Startupbootcamp Australia가 이끄는 사전 시드 라운드 확보

Startup romena The Connecter garante rodada de pré-semente liderada por Hatcher+ e Startupbootcamp Austrália

Румынский стартап The Connecter выиграл предварительный раунд под руководством Hatcher+ и Startupbootcamp Australia

Rumen Startup The Connecter, Hatcher+ ve Startupbootcamp Avustralya liderliğindeki ön tohumlama turunu garantiledi

Công ty khởi nghiệp Rumani The Connecter giành được vòng sơ tuyển do Hatcher+ & Startupbootcamp Australia dẫn đầu

罗马尼亚初创公司 The Connecter 获得 Hatcher+ 和 Startupbootcamp Australia 领投的种子轮融资

Motivation and Introduction As part of the software team at Nevados we are building an operations and monitoring platform for the Nevados All Terrain Tracker®. A solar tracker is a device that orients a solar panel toward the sun. Every solar tracker constantly sends status information and readings, such as the current angle, temperature, voltages, etc. to our platform and we need to store this information for analysis and visualization. If the tracker is configured to send data every 5 seconds, we have 17,280 data points per tracker per day, 518,400 data points per tracker per month. That sums up a lot of information. This kind of data is called "time-series data" and as for all complex problems in software, there are several solutions (Time Series Databases) for it. The most famous ones being InfluxDB and TimescaleDB. For our platform, we decided to work with , a relatively new product that is optimized for IoT applications and works with the SQL query language. TDEngine There were several arguments for this decision: TDEngine is open source is optimized for IoT applications uses SQL, which is a language we are familiar with is available as a managed service and we can focus on building our application is easy to run locally via Docker In this article, we'll go through the setup of a TDEngine database and tables and how to craft a GraphQL schema that allows us to query the data from various clients and applications. Getting started with TDEngine The easiest way to get started with TDEngine is to use their cloud service. Go to the and create an account. They have a few public databases we can use, which is great to put together a demo or experiment with queries. TDEngine If you want to run TDEngine locally, you can use the Docker image and to retrieve data from various sources and send them to the database, such as system information, ping statistics etc. Telegraf version: '3.9'

services:
  tdengine:
    restart: always
    image: tdengine/tdengine:latest
    hostname: tdengine
    container_name: tdengine

    ports:
      - 6030:6030
      - 6041:6041
      - 6043-6049:6043-6049
      - 6043-6049:6043-6049/udp
    volumes:
      - data:/var/lib/taos

  telegraf:
    image: telegraf:latest
    links:
      - tdengine
    env_file: .env
    volumes:
      - ./telegraf.conf:/etc/telegraf/telegraf.conf Check out the and the . In short, this would look something like this to connect to an MQTT topic: official documentation for the Telegraf configuration TDEngine documentation on Telegraf [agent]
  interval = "5s"
  round_interval = true
  omit_hostname = true

[[processors.printer]]

[[outputs.http]]
  url = "http://127.0.0.1:6041/influxdb/v1/write?db=telegraf"
  method = "POST"
  timeout = "5s"
  username = "root"
  password = "taosdata"
  data_format = "influx"

[[inputs.mqtt_consumer]]
  topics = [
    "devices/+/trackers",
  ] Instead of setting everything up locally and waiting for the database to fill with information, we'll use the public database for this article, which contains ship movements from the 5 major US ports. Using TDEngine with public ship movement data By default, the tables in TDEngine have an implicit schema, which means the schema adapts to the data that is written to the database. This is great for bootstrapping, but eventually, we want to switch to an explicit schema to avoid issues with incoming data. One thing that takes a little time to get used to is their concept of ("STable" for short). In TDEngine there are tags (keys) and columns (data). For each key combination, a "table" is created. All tables are grouped in the STable. Super Tables Looking at the database, they have one STable called which contains a lot of tables. Usually, we do not want to query on a per-table basis, but always use the STable to get accumulated data from all tables. vessel ais_data TDEngine has a function which allows us to inspect the schema of a table or STable. The has the following schema: DESCRIBE ais_data The STable has two keys and six data columns. The keys are the and the . We can use regular SQL statements to query the data: mmsi name SELECT ts, name, latitude, longitude FROM vessel.ais_data LIMIT 100;

ts                        name      latitude   longitude
2023-08-11T22:07:02.419Z  GERONIMO  37.921673 -122.40928
2023-08-11T22:21:48.985Z  GERONIMO  37.921688 -122.40926
2023-08-11T22:25:08.784Z  GERONIMO  37.92169  -122.40926
... Keep in mind that time-series data is usually very large, so we should always limit the resultset. There are a few time-series specific functions that we can use, like which groups results by key and is useful to get the latest update individual keys. For example: PARTITION BY SELECT last_row(ts, name, latitude, longitude) FROM vessel.ais_data PARTITION BY name;

ts                        name      latitude   longitude
2023-09-08T13:09:34.951Z  SAN SABA  29.375961 -94.86894
2023-09-07T18:05:01.230Z  SELENA  33.678585 -118.1954
2023-09-01T17:23:24.145Z  SOME TUESDAY  33.676563 -118.230606
... I recommend reading their for more examples. Before we move on, head to "Programming", "Node.js" and retrieve your and variables. SQL Documentation TDENGINE_CLOUD_URL TDENGINE_CLOUD_TOKEN GraphQL with Nexus.js, Fastify and Mercurius GraphQL is pretty well known these days and there are lots of good articles about it. We chose the technology as we collect and process information from different sources and GraphQL allows us to combine them into a single API transparently. We'll use the amazing framework (by now the default choice for Node.js applications) and the adapter. The teams of Mercurius and Fastify worked together for a seamless experience and it's a great choice GraphQL APIs with a focus on performance. is a tool to build/generate the schema and resolvers, so we do not have to write everything by hand. Fastify Mercurius GraphQL Nexus There's a bit of setup code etc. to be done, which I'll skip here. You can find a full example on . GitHub - tdengine-graphql-example I want to elaborate on two things in this article that are rather specific: the TDEngine Query library the GraphQL schema with Nexus TDEngine Query library TDEngine has a that allows us to query the database. This makes it easy to connect and send queries, unfortunately the responses are a little difficult to work with. So we wrote a little wrapper: Node.js library 'use strict'

import tdengine from '@tdengine/rest'
import { tdEngineToken, tdEngineUrl } from '../config.js'
import parseFields from 'graphql-parse-fields'

const { options: tdOptions, connect: tdConnect } = tdengine
tdOptions.query = { token: tdEngineToken }
tdOptions.url = tdEngineUrl

export default function TdEngine(log) {
  this.log = log
  const conn = tdConnect(tdOptions)
  this.cursor = conn.cursor()
}

TdEngine.prototype.fetchData = async function fetchData(sql) {
  this.log.debug('fetchData()')
  this.log.debug(sql)

  const result = await this.cursor.query(sql)
  const data = result.getData()
  const errorCode = result.getErrCode()
  const columns = result.getMeta()

  if (errorCode !== 0) {
    this.log.error(`fetchData() error: ${result.getErrStr()}`)
    throw new Error(result.getErrStr())
  }

  return data.map((r) => {
    const res = {}
    r.forEach((c, idx) => {
      const columnName = columns[idx].columnName
        .replace(/`/g, '')
        .replace('last_row(', '')
        .replace(')', '')
      if (c !== null) {
        res[columnName] = c
      }
    })
    return res
  })
} This returns a TDEngine object that can be passed into GraphQL context. We'll primarily be using the function where we can pass in a SQL query and get the results back as an array of objects. TDEngine returns the metadata (columns), errors and data separately. We'll use the metadata to map the columns into a regular list of objects. A special case here is the function. The columns are returned as , etc. and we want to remove the part so the attribute maps 1:1 to the GraphQL schema. This is done in the part. fetchData last_row last_row(ts) last_row(name) last_row columnName.replace GraphQL Schema Unfortunately there is no schema generator like for TDEngine and we don't want to write and maintain a pure GraphQL schema, so we'll use Nexus.js to help us with that. We'll start with two basic types: and (which is a scalar type). and are two different types to display the date as a timestamp or as a date string. This is useful for the client application (and during development), as it can decide which format to use. allows us to use the type as a function in the schema. We can resolve the right here in the type definition to use the original timestamp value. Postgraphile VesselMovement Timestamp Timestamp TDDate asNexusMethod VesselMovement TDDate ts import { scalarType, objectType } from 'nexus'

export const Timestamp = scalarType({
  name: 'Timestamp',
  asNexusMethod: 'ts',
  description: 'TDEngine Timestamp',
  serialize(value) {
    return new Date(value).getTime()
  }
})

export const TDDate = scalarType({
  name: 'TDDate',
  asNexusMethod: 'tdDate',
  description: 'TDEngine Timestamp as Date',
  serialize(value) {
    return new Date(value).toJSON()
  }
})

export const VesselMovement = objectType({
  name: 'VesselMovement',
  definition(t) {
    t.ts('ts')
    t.tdDate('date', { resolve: (root) => root.ts })
    t.string('mmsi')
    t.string('name')
    t.float('latitude')
    t.float('longitude')
    t.float('speed')
    t.float('heading')
    t.int('nav_status')
  }
}) For time-series types, we use the or suffix for a clear separation of relational and time-series types in the interface. Movement Series Now we can define the Query. We'll start with a simple query to get the latest movements from TDEngine: import { objectType } from 'nexus'

export const GenericQueries = objectType({
  name: 'Query',
  definition(t) {
    t.list.field('latestMovements', {
      type: 'VesselMovement',
      resolve: async (root, args, { tdEngine }, info) => {
        const fields = filterFields(info)
        return tdEngine.fetchData(
          `select last_row(${fields}) from vessel.ais_data partition by mmsi;`
        )
      }
    })
  }
}) is a great tool to test the API and explore the schema, you can enable it by passing in Mercurius. With the query, we can see the latest movements of vessels grouped by . Let's go a little further though. One of the biggest advantages of GraphQL is that is is a transparent layer to the client or application. We can fetch data from multiple sources and combine them into the same schema. GraphiQL graphiql.enabled = true mmsi Unfortunately, I wasn't able to find an easy/free API with extensive vessel information. There is , but they only provide the , and in their Vessel response (which we already have in TDEngine). For the sake of the example, we assume we do not have the in our database and we need to retrieve it from Sinay. With the we could also query CO2 emissions for a vessel or another API could be used to retrieve an image, the flag or other information, all of which can be combined in the type. Sinay name mmsi imo name imo Vessel export const Vessel = objectType({
  name: 'Vessel',
  definition(t) {
    t.string('mmsi')
    t.string('name')
    t.nullable.string('imo')
    t.list.field('movements', { type: 'VesselMovement' })
  }
}) As you can see here, we can include a list field with the time-series data from TDEngine. We'll add another query to fetch the vessel information and the resolver allows us to combine the data from TDEngine and Sinay: movements t.field('vessel', {
  type: 'Vessel',
  args: {
    mmsi: 'String'
  },
  resolve: async (root, args, { tdEngine }, info) => {
    const waiting = [
      getVesselInformation(args.mmsi),
      tdEngine.fetchData(
        `select * from vessel.ais_data where mmsi = '${args.mmsi}' order by ts desc limit 10;`
      )
    ]

    const results = await Promise.all(waiting)
    return {
      ...results[0][0],
      movements: results[1]
    }
  }
}) 🎉 and here we have a working GraphQL API returning rows from TDEngine for a specific vessel we requested. is a simple wrapper to fetch data from Sinay. We'll add the TDEngine results into the attribute and GraphQL will take care of the rest and map everything to the schema. getVesselInformation() movements Note: SQL Injection As with any SQL database, we need to be careful with user input. In the example above we use the input directly, which makes this query vulnerable to SQL injections. For the sake of the example, we'll ignore this for now, but in "real world" applications, we should always sanitize user input. There are several small libraries around to sanitize strings, in most cases we only rely on numbers (pagination, limit etc.) and enums (sort order), which GraphQL checks for us. mmsi Thanks to Dmitry Zaets for pointing this out! Optimizations There are a few things that go beyond the scope of this article, but I want to mention them briefly: Pothos as spiritual successor to Nexus.js When we started the project, Nexus.js was the best choice to generate our GraphQL schema. Although stable and , it lacks maintenance and updates. There is a plugin-based GraphQL schema builder called which is a bit more modern and actively maintained. If you're starting a new project, I probably recommend using Pothos instead of Nexus.js. somewhat feature-complete Pothos Thanks to Mo Sattler for pointing this out! Field Resolvers As you can see in the resolver above, both data sources are immediately fetched and processed. This means if the query is only for the , we still fetch the for the response. And if the query is for the only, we still fetch the name from Sinay and potentially pay for the request. Vessel name movements movements That's a GraphQL anti-pattern and we can improve the performance by using the field information to only fetch the data that is requested. Resolvers have the field information as the fourth argument, but they're pretty difficult to work with. Instead, we can use to get a simple object of the requested fields and adjust the resolver logic. graphql-parse-fields SQL Query Optimizations In our example queries, we use to fetch all columns from the database even if they're not needed. This is obviously pretty bad and we can use the same field parser to optimize the sql queries: select * export function filterFields(info, context) {
  const invalidFields = ['__typename', 'date']
  const parsedFields = parseFields(info)
  const fields = context ? parsedFields[context] : parsedFields
  const filteredFields = Object.keys(fields).filter(
    (f) => !invalidFields.includes(f)
  )
  return filteredFields.join(',')
} This function returns a comma-separated list of fields from the GraphQL info. const fields = filterFields(info)
return tdEngine.fetchData(
  `select last_row(${fields}) from vessel.ais_data partition by mmsi;`
) If we request , and , the query would look like this: ts latitude longitude select last_row(ts, latitude, longitude) from vessel.ais_data partition by mmsi; With only a few columns in this table this might not matter much, but with more tables and complex queries, this can make a huge difference in application performance. Time Series functions TDEngine has some time-series specific extensions that should be used to improve performance. For example, to retrieve the latest entry, a traditional SQL query: SELECT ts, name, latitude, longitude FROM vessel.ais_data order by ts desc limit 1; Takes 653ms to execute, while the "TDEngine" query takes only 145ms: SELECT last_row(ts, name, latitude, longitude) FROM vessel.ais_data; There are configuration options for each table to optimize for last_row/first_row functions and other cache settings. I recommend reading the . TDEngine documentation Conclusion The simple version: In this article, we've set up a TDEngine time-series database and defined a GraphQL schema to allow client applications to connect & query data. There's a lot more to it. We have a boilerplate project to combine complex time-series data with relational data in a transparent interface. At Nevados, we're using PostgreSQL as a primary database and retrieve time-series data the same way as in the example above. This is a great way to combine data from multiple sources in a single API. Another benefit is that the data is only fetched when requested, which adds a lot of flexibility to the client application. Last but not least, the GraphQL Schema works as a documentation and contract, so we can easily tick the "API Documentation" box. movement , please or . If you have any questions or comments reach out on BlueSky join the discussion on GitHub Also published . here

Creating a Time Series Database With TDEngine and GraphQL

TDEngine এবং GraphQL দিয়ে একটি টাইম সিরিজ ডেটাবেস তৈরি করা

Erstellen einer Zeitreihendatenbank mit TDEngine und GraphQL

Creación de una base de datos de series temporales con TDEngine y GraphQL

Création d'une base de données de séries chronologiques avec TDEngine et GraphQL

TDEngine और GraphQL के साथ एक टाइम सीरीज़ डेटाबेस बनाना

TDEngine と GraphQL を使用した時系列データベースの作成

TDEngine 및 GraphQL을 사용하여 시계열 데이터베이스 생성

Criando um banco de dados de série temporal com TDEngine e GraphQL

Создание базы данных временных рядов с помощью TDEngine и GraphQL

TDEngine ve GraphQL ile Zaman Serisi Veritabanı Oluşturma

Tạo cơ sở dữ liệu chuỗi thời gian với TDEngine và GraphQL

使用 TDEngine 和 GraphQL 创建时间序列数据库

AVR Microcontroller Testing Procedures

One of the various projects associated with Project Xanadu™[1] was ZigZag™, a kind of organizer system or mind-mapping tool built around twisted multi-dimensional spaces called ZZStructures. From the beginning, we wanted to make this system scriptable. Some existing internal implementations supported scripting in conventional languages, and Ted wanted a spreadsheet-formula-like language (since he thought of a ZZStructure as a kind of spreadsheet whose rows and columns were set free from their grid and tangled up in arbitrarily expressive ways). When I was there, Jon Kopetz and I came up with the concept of a language that took more full advantage of the structures available, and I wrote a proof-of-concept implementation. It was not persued further — the language wasn’t really accessible to non-programmers the way a formula system might be, and we had other priorities — but I consider some of the ideas valuable, since, for all its limitations, it sits at the intersection of literate programming, stack programming, and visual programming. Quick legal note Project Xanadu produces a lot of code internally — a lot more than ever gets released — and a lot of internal documents and discussions. The code I’m linking to was written independently, from memory, based on things that I wrote for Xanadu. However, it is not officially blessed by the project, so the various trademarks (Project Xanadu™, ZigZag™, the flaming X logo, and probably others) don’t apply. As far as I am aware, this material does not violate any trade secrets — all trade-secrets related to ZigZag™ that I was privy to have been made public. Also, while patents related to this tech were filed, to my knowledge no applicable patents are currently in force. From now on, I will refer to ZigZag™-like systems as ZZ. These ideas do not necessarily rely upon all of the features of ZigZag™, but may be applied to any system based on a ZZStructure. Also, I hate typing trademark slugs. A crash course in ZZStructures and ZZ interface conventions A ZZStructure is a collection of ‘cells’ — objects containing a value and a string-keyed associative array of pairs of pointers to other cells.[2] A programmer might conceptualize a cell as the intersection of arbitrarily-many doubly-linked lists, each with a name. Alternately, they might see a cell as a point in a tangled multi-dimensional space (hence why the names given to these lists are called “dimensions”). A very twisted portion of a ZZStructure, with two visible dimensions, as seen in the gzz implementation of ZigZag A full ZZStructure implementation can be written in . For the sake of explanation, here is an even-more-simplified version: 200 lines of python cells=[] class ZZCell:def __init__(self, value=None):global cellsself.cid=len(cells)self.value=valueself.connections={}self.connections[True]={}self.connections[False]={}cells.append(self)# core operationsdef getValue(self):""" get cell's value. Use this, rather than the value attribute, unless you specifically don't want to handle clones """return self.cloneHead().valuedef getNext(self, dim, pos=True):if dim in self.connections[pos]:return self.connections[pos]return Nonedef insert(self, dim, val, pos=True):""" like setNext, except it will repair exactly one connection """if(dim in self.connections[pos]):temp=self.connections[pos][dim]self.setNext(dim, val, pos)val.setNext(temp, val, pos)else:self.setNext(dim, val, pos)def breakConnection(self, dim, pos=True):if self.getNext(dim, pos):temp=self.connections[pos][dim]temp.connections[not pos][dim]=Noneself.connections[pos][dim]=Nonedef clone(self):""" create a clone """c=ZZCell()self.rankHead("d.clone", True).setNext("d.clone", c)return cdef cloneHead(self):return self.rankHead("d.clone")# underlying operations (usually not exposed through the UI)def setNext(self, dim, val, pos=True):self.connections[pos][dim]=valval.connections[not pos][dim]=selfdef rankHead(self, dim, pos=False):""" Get the head (or tail) of a rank """curr=selfn=curr.getNext(dim, pos)while(n):if(n==self):break    # handle ringrankscurr=nn=curr.getNext(dim, pos)return currdef getDims(self):return list(set(self.connections[True].keys() + self.connections[False].keys())) Generally speaking, a conventional ZZ interface (a “view”) will consist of two panes, each with a particular cell selected and with two or three dimensions mapped to the spacial dimensions of the pane. Users navigate both panes simultaneously, or use each pane to view different aspects of the same cell (in the form of connections along different dimensions). This article will be illustrated with hand-drawn images of a simplified ZZ interface of this type. ZZ keybindings and interactions are beyond the scope of this article, although I encourage those interested to read and watch . the official documentation in the ‘starter kit’ the demonstration video A demonstration of the use of ZigZag for organic chemistry Ted Nelson explains ZigZag Another demonstration of ZigZag, this time at the Internet Archive Kaukatcr (pronounced “cowcatcher”[3]) is a stack-based language modeled loosely on Forth. It avoids tokenization by treating cell boundaries as word boundaries. Like Forth, any word that is neither a built-in nor found in the dictionary of defined functions will be treated as data and pushed onto the stack. Kaukatcr Kaukatcr has an ‘interpreter head’ — a cell that corresponds to the beginning of the program. The stack hangs off the interpreter head along the dimension ‘d.stack’ ; the names of defined functions hang off it along ‘d.funcs’; the call stack hangs off it along ‘d.call’; the interpreter iterates along ‘d.exec’. Function definitions hang off their names along ‘d.exec’. ‘d.branch’ points to the targets of conditional jumps. By convention, we hang comments off of our code along ‘d.comment’. For the sake of readability for non-Forth-programmers, a few Forth keywords have been renamed: ‘:’ becomes ‘def’ and ‘;;’ becomes ‘end’.[4] Function definition, nevertheless, works approximately the same way: : 2dup swap dup rot dup ;; becomes: The ‘ret’ is required because we do not automatically return from calls when they exit — without the ‘ret’, the program will terminate when it walks off the end of a rank. This makes it a little easier to exit a program early, and so supports interactive editing — one can observe the stack during execution of an unfinished program, perhaps edit it, and then resume at an exit point. Once the code defining that function has been read, our interpreterHead will look like this: Finally, here’s an example with both functions and conditional branches: Differences from Forth Despite borrowing some syntax and conventions from Forth, there are fundamental differences (even beyond tokenization, which is not configurable in kaukatcr). One difference is that builtins are not overridden by defined words with the same name. In the reference implementation, user defined function lookup is so much slower than builtins lookup that performing it on every step would be unreasonable for large programs. Furthermore, while redefining builtins is very powerful, it makes the most sense in a system that can easily have its state reset (to revert all possible breaking changes), while ZZ implementations theoretically should be image-based systems (like smalltalk VMs) where every change is automatically saved to persistent state. (Few-to-none of the actual implementations do this, but all of them are supposed to, according to design specs.) Another difference is that ‘if’, being non-linear, doesn’t come with ‘else’ and ‘endif’ and friends — instead, it’s essentially a conditional branch. It operates equivalently to the ‘jnz’ instruction in x86 assembly. As a result, ‘if’ can be modified to act as an arbitrary ‘goto’ — just push 1 onto the stack before an if, and you can jump unconditionally to anywhere in the code. In the current implementation, because we jump to the linked cell instead of the clonehead[5] of the linked cell, each cell can be the entrance point for at most one direct branch — however, I see no reason this couldn’t be an implementation-dependent or dialect-dependent decision. Limiting jump points in this way makes analyzing certain structures easier since they collapse into well-defined loops, but circumventing this in order to jump to a particular point from many places involves injecting a bunch of no-op instructions, which should be avoided.[6] In this contrived example, we show how following clones to their origin (shown via dotted line) might simplify structure. Assume that we have already run the code “def nop ret end” A third difference is the manipulation of larger data structures. Since all data is either ZZ cells, clones of ZZ cells, or strings or numbers stored in ZZ cells[1], and because ZZ navigation is exposed, it’s natural to use ranks as 1d arrays and to use cells with known sets of dimensions hanging off of them as associative arrays. For multidimensional arrays, I recommend using the convention of d.1, d.2, …, d.n and navigating those structures in the order of the cardinal dimension (i.e., to navigate to (3, 5, 7) we would go three steps along d.1, five steps down d.2, and then seven steps across d.3) — although obviously Kaukatcr is not a good choice for complex matrix arithmetic. A procedure for getting the item at a certain index in a 2d array. On the stack at call time: y-coordinate, x-coordinate, and the cell-id of the head of the matrix. Footnotes [1] Project Xanadu™ is the original hypertext project, formed in 1960 and still going. I worked there, in a volunteer capacity, from 2011 to 2016. It’s the brainchild of Theodor “Ted” Nelson. I recommend looking at . the official website for more details [2] To be more accurate, a collection of cells is called a ‘slice’, and a ZZStructure may be composed of one or more slices. The module, as defined, only supports one slice (the ‘cells’ array at module scope). In other implementations, there is a slice class, which handles cell creation, garbage collection, serialization, and the allocation of cell IDs; however, I thought this might be too confusing for people unfamiliar with the concepts I’m trying to introduce. Anyhow, supporting multiple slices is mostly interesting because of the ability to link across slice boundaries — the mechanisms for which were at one time under trade secret. While I believe those trade secret protections are now void, I’m erring on the side of caution by avoiding detailed descriptions or implementations of them. [3] The cowcatcher is the wedge-shaped construction found at the front of steam trains. It was invented by Charles Babbage, who also invented the stored-program mechanical computer. We chose this name because of this, and because the movement of the instruction pointer in two dimensions reminded us of a train following tracks. ‘Kaukatcr’ is the phonetic representation of ‘cowcatcher’ in the most popular lojban orthography. [4] Some of my examples used ‘:’ by accident. So, I believe, did the internal prototype I initially developed. I have modified the implementation to support Forth-style word definitions. Writing and modifying this kind of code is very easy to do with a real zigzag interface, but quite awkward in GIMP! [5] The ‘clonehead’ is the original from which some cell is cloned, if the cell in question is a clone. Mechanically, cloning works in ZZ by creating a rank of blank cells hanging off the original along d.clone — so, the clonehead is the head of the rank along d.clone. When we get the content/value of a cell, we automatically forward that content request to the clonehead, so from a UI perspective (and the perspective of anything that ‘reads’ the content of a cell) a clone contains the same content as the original. [6] As you can see from the example, dereferencing clones makes certain kinds of code easier to write, but it has ramifications both for how function definition works (since currently it just clones the original function source) and for the regular use of the system. In particular, a user of a ZZ system might expect to be able to clone pieces of data from other programs or from non-code portions of his slice into his code in order to manipulate it, and dereferencing will break this behavior in potentially confusing ways.

Kaukatcr: an experiment in language design for multi-dimensional spaces

Source: @jamesshamsi (Instagram) Did you hear about the guy that hid $10,000 inside of 200 fake vaginas? How about the one that tried to online with Kardblock? (which it turns out was an SEO PR stunt, see James’ Entertainment Tonight interview ). kill the Kardashians here The one that got to publicly apologize to him over ?(see more of that ) Instagram manboobs, as part of the #freethenipplecampaign here Drove over for free on ? 900 million views Facebook The guy that with a Snapchat filter? hijacked TechCrunch’s summer party Or, the one that on Kickstarter in ? raised over half a million dollars less than 30 days Recently growing influencer Julius Dein on Facebook from Maybe the guy that creates influencers? o to 8 million likes in 2 years. The guy that used to get his first graduate job? Tinder Maybe the man that made an app that allowed you to so you get more swipes? (which turned out to be a clever PR stunt) photoshop puppies into your pictures Recently created a way to ? blow up Instagram followings for models, creating influencers These are just a small handful of the stunts and viral projects that Shamsi can publicly disclose… Meet , dubbed a ‘ savant’ by Business Insider — and for good reason… James Shamsi social media , has been responsible for some of the biggest viral campaigns and PR stunts of the past few years, accumulating over 900m views on his work. Shamsi, a 23-year old Brit now living in LA Though he can’t talk publicly talk about his stunts with major A-list celebrities, artists and brands, he strives to make himself go viral to prove he knows his craft too. created the viral sensation (which turned out to be an SEO stunt), to receiving global news coverage for fighting for female nipple rights by uploading in a very clever way… For example: Shamsi Kardblock male nipples to Instagram He’s also used his tactics so raise on Kickstarter, shown how to make money from Snapchat by using of product. $500,000 in 30 days 10 second snaps to sell $7,000+ worth Shamsi is the brains behind multiple major viral campaigns and PR stunts that you would’ve seen in the past 3 years. This is just a small snapshot, see more of his work . here How does he do it? Shamsi’s mantra is to be cheap and lazy. Cheap, as it forces you to be lean. Lazy, as it forces you to find the most efficient possible solutions. Through the most genius hustle I’ve ever seen. As he says himself: “I’ don’t like spending money. I’ve actually never spent a single dollar on PR. But, I get myself AND my clients millions of views per campaign, and secure front page coverage on sites like Mashable, The Washington Post, The Observer, The Hollywood Report, and TV coverage on the likes on Entertainment Tonight, Good Morning America, The Today Show, Jimmy Kimmel and a fuck ton of others. It requires creativity… and the most overused word of this year — hustle. Going viral doesn’t require money. Shamsi doing an interview on Entertainment Tonight for his Kardblock PR stunt. Take the $10,000 + 200 fake vagina stunt for example…. This was a stunt for a brand with YouTubers where the idea was to hide money filled sex toys as a public “Easter egg hunt”. One of the many ways Shamsi got free coverage for this isn’t because of any connections. Instead, Shamsi made a list of VERY conservative media outlets, from Christian radio stations to strong conservative blogs and begun contacting them, pretending to be a concerned parent for example. The result? He organized marches and blogs against . HIMSELF He boasts: Haha yes for the vagina thing I actually got a super conservative religious group to send an email to all their 100,000+ members denouncing the campaign… little did they realize that by doing that they got people talking about it so much that it helped me get covered in Playboy and other mainstream publications, Using this same ‘broke mentality’, as Shamsi describes, he spent 2 months every day running tests to figure out how to hack Facebook growth. The result? He’s able to create influencers at will. One of James’s clients, Kristen Hanby, a Facebook influencer he helped grow from from 0 to 1m in a year. Having grown influencer on Facebook in 2 years, James now has his sights set on Instagram. Julius Dein from 0 to 8,000,000+ likes In the past few months he’s broken the algorithm for growth for INSTAGRAM too. Within a month of working with one of his influencers, James has single handedly driven millions of views to her profile within a mere few weeks. This is what her stats were like before and after. Something which influencers jokingly call, ‘The Shamsi Effect’: James says he now has , and well… the proof’s in the pudding, as the British would say. the secret formula to going viral on Instagram Shamsi showed me a little peek into the stats of one of his influencers… and the results are undeniable. Check out his most recent work with model @morganketzner, who hit1 million views with (what was at the time) 50,000 followers: Source: Instagram — @jamesshamsi This below post is from an influencers account who has less than 350,000 followers, but with ‘the shamsi effect’ her post was seen by 6 million people. “She averaged 300,000 views on her own, which is cool don’t get me wrong. Since using my new formula with her, we’ve insanely multiplied her growth, engagement and views. We’ve had two of her videos hit 4 million views, and 3 others hit 1 million — all in under 1 month. There is a secret way to go viral on Instagram” — James. The Connect Collective , the next big thing… From this success and his secrets to hacking Instagram growth, James has now co-founded The Connect Collective — a service for influencers to rapidly grow their following on Instagram and get high end brand deals. See more on www.theconnectollective.co By taking a new data driven approach to Instagram growth hacking their team have create a secret sauce for Instagram growth — check out a snapshot of one of their clients daily growth below: A snapshot of Instagram growth from one of Runway Media’s latest clients. So what’s the latest crazy thing James’s done ? Well, a few months ago Snapchat begun allowing people to buy geofilters, giving everyone the option to place a custom geofilter at a place of their desire for a short time. So far it’s been used predictably for private events with generic filters, e.g. ones like ‘50th annual cupcake convention’, or ‘Mikes 20th birthday’ as banners… that was until now. Shamsi, (who is also a tech start-up advisor), heard of TechCrunch’s annual summer party — but his excitement was short-lived once he saw the $85 price tag for a ticket. Here’s his reaction: “I saw it was $85, and I was like f**k that, I’m not paying that much to just network no matter who’s there” The solution? “Instead of buying a ticket for $85, I realized I could just buy a Snapchat geo filter for $5 that covers the entire event. Not only does this save me a f**k ton of money, but it also makes it so much more efficient, as I can now leave a lasting impression on all the VC’s, influencers, start-ups etc there — as opposed to spending the day talking talking to just just 15–20 people”. Here it is… the big ‘F YOU’ geofilter to TechCrunch: Source: @snapkarenx Shamsi said he got over 7,000 impressions, coming from 64 silicon valley and social media influencers taking selfies and using his filter — considering this was an incredibly niche event with high profile angels, investors and heavy weights in the tech sphere (who also have influential followers)… this is pretty epic. What was the result? Source: www.JShamsi.com So, what does this all mean? Speaking with James has opened my eyes. Stop doing things the traditional way, stop using agencies and stop following the rules. If you want results like Shamsi’s, you have to start thinking outside the box. Subscribe to HackerNoon for more like this: https://hackernoon.com/ Want to contact or learn more about James? Instagram — www.instagram.com/jamesshamsi Facebook — www.facebook.com/james.shamsi Website — www.JShamsi.com/ig The Connect Collective — www.TheConnectCollective.co Let me know by sharing it with a friend :) Like this article?

https://upscri.be/hackernoon/Meet James Shamsi — The King of VIRAL.

A minority, but still a massive number of projects, require web sockets integration to provide instant reaction of an interface on changes without re-fetching data. It’s an essential thing, and we are not going to talk about them or make a comparison between 3rd-party libraries that provide API for a better dev experience. My goal is to show how to integrate quickly with NextJs. And how to solve the problems we faced during development. @microsoft/signalr I hope everyone has already installed and deployed the NextJS project locally. In my case, the version is . Let’s add some more important libraries: (version ) for data fetching and further work with the local cache and (version ) - API for web sockets. 13.2.4 swr 2.1.5 @microsoft/signalr 7.0.5 npm install --save @microsoft/signalr swr Let’s start with creating a simple function and a new hook called to get initial data from our REST API. It returns a list of the messages for the chat, fields that detect errors and loading state, and the method that allows to change cached data. fetcher useChatData mutate // hooks/useChatData.ts
import useSWR from 'swr';

type Message = {
    content: string;
    createdAt: Date;
    id: string;
};

async function fetcher<TResponse>(url: string, config: RequestInit): Promise<TResponse> {
    const response = await fetch(url, config);
    if (!response.ok) {
        throw response;
    }
    return await response.json();
}

export const useChatData = () => {
    const { data, error, isLoading, mutate } = useSWR<Message[]>('OUR_API_URL', fetcher);
    return {
        data: data || [],
        isLoading,
        isError: error,
        mutate,
    };
}; To test that it works as it is supposed, let’s update our page component. Import our hook at the top, and extract data from it like in the snippet below. If it works, you will see rendered data. As you see, it’s quite simple. // pages/chat.ts
import { useChatData } from 'hooks/useChatData';

const Chat: NextPage = () => {
	const { data } = useChatData();

	return (
		<div>
            {data.map(item => (
                <div key={item.id}>{item.content}</div>
             ))}
        </div>	
	);
}; The next step requires connecting our future page to web sockets, catching events, and updating a cache with a new message. I propose to start with building the socket service in a separate file. NewMessage According to the examples in SignalR docs, we have to create an instance of connection for further listening to events. I also added a connections object for preventing duplicates and two helpers to start/stop the connections. // api/socket.ts
import { HubConnection, HubConnectionBuilder, LogLevel } from '@microsoft/signalr';

let connections = {} as { [key: string]: { type: string; connection: HubConnection; started: boolean } };

function createConnection(messageType: string) {
    const connectionObj = connections[messageType];
    if (!connectionObj) {
        console.log('SOCKET: Registering on server events ', messageType);
        const connection = new HubConnectionBuilder()
            .withUrl('API_URL', {
                logger: LogLevel.Information,
                withCredentials: false,
            })
            .withAutomaticReconnect()
            .build();

        connections[messageType] = {
            type: messageType,
            connection: connection,
            started: false,
        };
        return connection;
    } else {
        return connections[messageType].connection;
    }
}

function startConnection(messageType: string) {
    const connectionObj = connections[messageType];
    if (!connectionObj.started) {
        connectionObj.connection.start().catch(err => console.error('SOCKET: ', err.toString()));
        connectionObj.started = true;
    }
}

function stopConnection(messageType: string) {
    const connectionObj = connections[messageType];
    if (connectionObj) {
        console.log('SOCKET: Stoping connection ', messageType);
        connectionObj.connection.stop();
        connectionObj.started = false;
    }
}

function registerOnServerEvents(
    messageType: string,
    callback: (payload: Message) => void,
) {
    try {
        const connection = createConnection(messageType);
        connection.on('NewIncomingMessage', (payload: Message) => {
            callback(payload);
        });
        connection.onclose(() => stopConnection(messageType));
        startConnection(messageType);
    } catch (error) {
        console.error('SOCKET: ', error);
    }
}

export const socketService = {
    registerOnServerEvents,
    stopConnection,
}; So now, our page might look like in the code snippet. We fetch and extract with the list of messages and render them. Also, above registers the event, creates a connection, and listens to the backend. data useEffect NewMessage When the event triggers, the method from the hook updates the existing list with a new object. mutate // pages/chat.ts
import { useChatData } from 'hooks/useChatData';
import { socketService } from 'api/socket';

const Chat: NextPage = () => {
	const { data } = useChatData();

	useEffect(() => {
        socketService.registerOnServerEvents(
            'NewMessage',
            (payload: Message) => {
                mutate(() => [...data, payload], { revalidate: false });
            }
        );
    }, [data]);

	useEffect(() => {
        return () => {
            socketService.stopConnection('NewMessage');
        };
    }, []);

	return (
		<div>
            {data.map(item => (
                <div key={item.id}>{item.content}</div>
            ))}
        </div>	
	);
}; Looks good to me, it works, and we see how new messages appear in the feed. I chose the basic example with chat because it’s clear and easy to understand. And, of course, you apply it on your own logic. Small Bonus Using one of the versions  ( ), we faced a problem with duplications. It was connected to , the dependency array. Each time the dependency was changed, cached callback and triggered it again and again. @microsoft/signalr useEffect connection.on(event, callback); useEffect(() => {
    // data equals [] by default (registerOnServerEvents 1 run),
    // but after initial data fetching it changes (registerOnServerEvents 2 run)
    // each event changes data and triggers runnning of registerOnServerEvents
    socketService.registerOnServerEvents(
        'NewMessage',
		// callback cached
        (payload: Message) => {
		// mutate called multiple times on each data change
            mutate(() => [...data, payload], { revalidate: false });
        }
    );
}, [data]);
// after getting 3 messages events, we had got 4 messages rendered lol The quickest and most reliable solution we found was keeping a copy of data inside the React and using it inside for future updates. ref useEffect // pages/chat.ts
import { useChatData } from 'hooks/useChatData';
import { socketService } from 'api/socket';

const Chat: NextPage = () => {
	const { data } = useChatData();
	const messagesRef = useRef<Message[]>([]);

	useEffect(() => {
	     messagesRef.current = chatData;
    }, [chatData]);

	useEffect(() => {
        socketService.registerOnServerEvents(
            'NewMessage',
            (payload: Message) => {
			    const messagesCopy = messagesRef.current.slice();
                mutate(() => [...messagesCopy, payload], { revalidate: false });
            }
        );
    }, [data]);

	useEffect(() => {
        return () => {
            socketService.stopConnection('NewMessage');
        };
    }, []);

	return (
		<div>
            {data.map(item => (
                <div key={item.id}>{item.content}</div>
            ))}
        </div>	
	);
}; Currently, we use a new version of which it seems already has necessary fixes. But anyway, if someone finds this solution useful and uses this workaround, I will be happy. To conclude, I want to say that my experience with SignalR is quite positive, installation didn’t require any specific dependencies or settings, and it works fine and covers our needs. @microsoft/signalr

Next.js and SignalR: Effortless Socket Integration and Troubleshooting

Next.js এবং SignalR: প্রচেষ্টাহীন সকেট ইন্টিগ্রেশন এবং ট্রাবলশুটিং

Next.js und SignalR: Mühelose Socket-Integration und Fehlerbehebung

Next.js y SignalR: integración de sockets y solución de problemas sin esfuerzo

Next.js et SignalR : intégration et dépannage de sockets sans effort

Next.js और सिग्नलआर: सहज सॉकेट एकीकरण और समस्या निवारण

Next.js と SignalR: 簡単なソケットの統合とトラブルシューティング

Next.js 및 SignalR: 손쉬운 소켓 통합 및 문제 해결

Next.js e SignalR: integração e solução de problemas de soquete sem esforço

Next.js и SignalR: простая интеграция сокетов и устранение неполадок

Next.js ve SignalR: Zahmetsiz Soket Entegrasyonu ve Sorun Giderme

Next.js và SignalR: Khắc phục sự cố và tích hợp ổ cắm dễ dàng

Next.js 和 SignalR：轻松的套接字集成和故障排除

Today, Ukrainian IT specialists found themselves in a difficult situation due to the war, but despite this, developers continue to work and even find new opportunities in this. Ukraine has a high level of digitalization, which surpasses many European countries, and our developers are ready to bring this unique experience to other countries. Why businesses not only should not be afraid to invest in Ukrainian developers but even should - in our article. Ukrainian IT industry and wartime The IT industry still retains the status of the most profitable in Ukraine. Thanks to higher salaries, the economy is now supported by these specialists, as they continue to pay taxes. In addition, most IT companies have taken care in advance to evacuate teams to safer regions of Ukraine, and even beyond. This made it possible to avoid a drawdown in the fulfillment of tasks and obligations to clients. At the same time, it took one to two weeks to debug operational processes, after which work and even hiring new employees resumed as usual. The coronavirus epidemic gave training in the issue of working in remote mode, and this sad experience came in handy in the new realities. Most of the companies moved to Lviv, Ivano-Frankivsk, Chernivtsi, and Uzhgorod. Moreover, a local IT hub was created in Western Ukraine, which made it possible to guarantee that the developer would not leave the project. As for European locations, most often the developers moved to Poland, Germany, Romania, and Spain. Guarantees for customers from Ukrainian companies in wartime Despite the hostilities in the country, Ukrainian IT companies comply with all agreements with customers. In particular, a number of measures have been taken in front of customers to ensure data security. Among the main measures: 1. Setting up a remote access policy: a clear indication of the hierarchy of access to information and instructing employees. 2. Choosing a technology stack: each technology and/or service has its own guarantees and level of security, when choosing a stack, all aspects must be taken into account. 3. Permanently log out: Your employees must log out of the system, as well as all services and tools, after verifying work with them. 4. Constantly updated: Everything needs improvement, and data protection practices are no exception. How does IT work help Ukraine? In addition to helping in the form of cyber troops, IT specialists are an essential part of replenishing the economy through taxation. In addition, a high level of income allows both the developers themselves and the owners of IT companies to donate large amounts to charity. The second aspect is the development of useful products. For example, the air raid warning application was developed in record time. And the TopDevs team created the UAConnect platform on their own, designed to help migrants and refugees. All these efforts help to bring the truth about the situation in Ukraine and support it. Is it worth it to work with Ukrainian IT companies during the war? Definitely yes. Ukraine still retains the status of a powerful IT hub, where most of the specialists have experience working with foreign companies and know foreign languages. In addition, developers have good expertise in a variety of projects and industries. Ukrainian specialists are more motivated than ever, they want to help the country, not forgetting about self-realization and development as specialists. This turns them into great performers who are ready to face any professional challenge. Another aspect is the support of the Ukrainian economy through hiring. Each paid order for product development is your contribution to the economy of the country in which there is a war. It is also supporting the families of developers, some of whom were left without a home and were forced to become internally displaced or even refugees. How does TopDevs work in the new environment? Our team has experience in remote work and experience in team relocation in 2014. We were preparing for the fact that we would have to relocate the team this time as well, or that part of the team might leave the city or country. We have carried out all the necessary technical preparations to avoid breaking deadlines in case of force majeure. Our entire team is safe and all operations are back to normal. , meet deadlines, participate in new projects and support each other. Our team understands the responsibility that lies with us, and we want to support the economy and develop as an IT company. We work on projects Final words The IT sector of Ukraine is gradually recovering, and although not all companies were able to survive the crisis caused by the war, the majority are already actively entering new markets and starting new projects. Everyone understands that the economy must be supported and invested in the future. Despite all the difficulties, the Ukrainian IT sector will continue to develop. The level of professionalism and motivation will become an additional incentive for developers. Thanks to the efforts of these specialists, a huge number of fees are constantly closed. Remember that cooperation with Ukrainian companies is not only about the quality of services but also about supporting Ukraine in the fight for freedom.

Why To Choose a Ukrainian Company For Your Project Development

Stories, News & Mentions about TAPCONNECT

Tapconnect’s Stories on HackerNoon