Event Connectis in the Events Tech Industry

Event Connect

LinkedIn is often tagged as a haven for B2B marketers. It's like a puzzle we're all trying to solve. You've likely been bombarded with advice: Stay active. Keep engaging. Make sure you're seen. But let's get real: there's more to the story. For nearly two years, I've been deep in the trenches, experimenting with different content recipes for SaaS companies on LinkedIn. Trust me, it’s a journey — there's no magic formula. Let’s dive into some specifics now on taking care of a LinkedIn company page. What Works For A B2B SaaS Company On LinkedIn People Matter, Really Every marketing 101 starts with, "focus on people," but here’s the real deal: your customers, event connections, prospects (with permission), and team are your secret sauce. Share their stories, their challenges, and their victories. These aren’t just faces; they’re the heart and soul behind your brand. Remember, behind every B2B transaction, there’s a human being, perhaps someone rushing to finish work and get back to their family. Make your content a helping hand, not just another sales pitch. The Power of Video In today's fast-paced world, grabbing someone's attention for even a minute feels like a win. And that's where videos come in – they really work. Imagine a small sales team or an estimator swamped during peak season. They stumble upon a video titled, “AI will not replace you - hear from a landscape estimator.” That’s going to hit home, guaranteed. If your video is about solving a real problem, people will connect with it. Beyond that, what else works? Simple: short clips that get straight to the point, animations that make a complex idea clear, or just a casual peek behind the scenes of your product. It’s Not All About You Sure, self-promotion is part of the game, but twist the narrative. Hosting a webinar? Don't just talk shop. Highlight your speakers, and share their lesser-known achievements or quirky hobbies. Make your audience feel like they're getting to know someone, not just attending another online event. Link Out, But Wisely LinkedIn might give you the cold shoulder for posting external links, but sometimes, it’s worth the risk. Share that insightful blog post or groundbreaking stat you saw the other day once in a while. It shows you're not just about your own content but about adding real value to your audience’s feed. Hashtag With a Human Touch Forget the jargon; hashtags are your virtual signposts. They guide your content to the right eyes. Sure, use the tried-and-tested ones, but don't be afraid to sprinkle in a few wildcards. Who knows, your next big client might be following a hashtag you haven’t tried yet. Real Photos, Real Impact Choose candid shots over picture-perfect stock images. A slightly blurry team photo or a candid shot at a product demo speaks volumes more than a polished, impersonal image. It’s about authenticity, about showing the real people behind the pixels. Collaborate With Voices, Not Just Profiles On LinkedIn, you’ll find more than just profiles. You’ll find voices eager to share, debate, and collaborate. Reach out to those who resonate with your brand and those who can add value to your audience. Whether it’s a joint blog post or a casual chat video, these collaborations can turn your page into a hub of fresh perspectives. Remember, it's not all about your product. Sometimes, the best content is about something your industry gets. Real stories, practical takeaways, the ups and downs of people’s careers – that stuff resonates. Got a connection with decades of experience? Sit down with them. Ask about their favorite aspect of the work, and get them to open up about why they love it. Then, share that story. Be it a blog or a video, if it has promise, it’ll get you traction. Over to You Embrace the experiment. There's no one-size-fits-all strategy here. As I navigate the waters with my new SaaS LinkedIn page, I invite you to share your journey too. What's been a game-changer for you? Any strategies that flopped? Hit me up with your stories, your wins, and even your 'not-so-great' moments.

Ups & Downs of Running A B2B SaaS LinkedIn Page: What To Do/What Not To Do

The Auction Events Platform is a Laravel PHP web application streaming live video from an auction event, using the LiveKit Open source WebRTC infrastructure. The Auction Events Platform for Creators The platform allows creators to run a live auction, a hybrid event, with bidders in the auction hall and online. Online bidders watch a live video and audio stream of the auction hall and bid via a web application. An auction event can be purely virtual with no auction hall. An auction may run for a few hours with items coming up for bidding in sequence. A creator runs the auction, streaming it from a camera and microphone attached to the creator's computer. The Platform Architecture The platform is a web application built with the TALL stack: Laravel Livewire Alpine.js Tailwind LiveKit LiveKit is an open-source platform for live audio and video. It works by creating rooms in which participants can join and then publish video and audio tracks. Other participants can subscribe to tracks published in the room and stream the track to an HTML and tags. video audio Running LiveKit First, you need to obtain the API key and secret and generate an initial configuration file, , by running: livekit.yaml docker run --rm -v$PWD:/output livekit/generate --local To operate a LiveKit in the simplest way possible, you run a docker container: docker run --rm -p 7880:7880 \
    -p 7881:7881 \
    -p 7882:7882/udp \
    -v $PWD/livekit.yaml:/livekit.yaml \
    livekit/livekit-server \
    --config /livekit.yaml \
    --node-ip <your local IP> Participants need to get an access token to interact with LiveKit in any way, such as to create a room or connect to a room. An access token carries certain permissions, such as creating rooms, subscribing to tracks, and publishing tracks. Using LiveKit for Live Streaming of Auctions In the Auction Events Platform for Creators, the platform generates the rooms a few hours before the auction. So the creators can get the setup right. The platform deletes the room a short while after the auction is completed. Creators publish video and audio, and bidders subscribe to the tracks and watch them. To integrate LiveKit into our platform, we use the On the server side - PHP Server SDK to LiveKit On the client side - LiveKit browser client SDK (javascript) We use the following LiveKit configuration: port: 7880
rtc:
    udp_port: 7882
    tcp_port: 7881
    use_external_ip: false
room:
    auto_create: false
keys:
    xxxxxxx: yyyyyy
logging:
    json: true
    level: debug
    pion_level: debug
webhook:
    api_key: xxxxxxxx
    urls:
        - <our webhooks url> Since the platform creates the rooms, we set to false, preventing a participant from creating a room upon joining it. auto_create Issue Access Tokens We have two types of users: Creators that publish video and/or audio Bidders that subscribe to the video and/or audio Consequently, we generate using the PHP SDK access token as: use Agence104\LiveKit\AccessToken;
use Agence104\LiveKit\AccessTokenOptions;
use Agence104\LiveKit\VideoGrant;

 // Define the token options.
 $token_options = (new AccessTokenOptions())
   ->setIdentity($participant_name)
   ->setTtl($key_expiry_seconds);

// Define the video grants.
$video_grant = (new VideoGrant())
  ->setRoomJoin(true) // TRUE by default.
        ->setRoomName($room_name)
    ->setCanPublish($is_creator) // only creators can publish
        ->setCanSubscribe(true) // TRUE by default.
        ->setRoomCreate(false); 


// Initialize and fetch the JWT access token. 
$token = (new AccessToken())
    ->init($token_options)
    ->setGrant($video_grant)
    ->toJwt(); Create and Delete Rooms On the server side, using the PHP SDK, Create Room use Agence104\LiveKit\RoomServiceClient;
use Agence104\LiveKit\RoomCreateOptions;

$opts = (new RoomCreateOptions())
    ->setName($room_name)
    ->setMaxParticipants(env('MAX_LIVEKIT_ROOM_PARTICIPANTS'))
    ->setEmptyTimeout(env('LIVEKIT_EMPTY_ROOM_TIMEOUT_SECONDS'));
$room = $svc->createRoom($opts); Delete Room $host = env('LIVEKIT_URL');
$svc = new RoomServiceClient($host);
$rsp = $svc->deleteRoom($room_name); Webhooks We use webhooks to listen to events in the room, such as participants joining and leaving, to control the room capacity. Routing The webhook part of the configuration points to a controller action through a file in : webhook.php routes use Illuminate\Support\Facades\Route;
use Illuminate\Http\Request;
use App\Http\Controllers\LiveKitWebhookController;

Route::post('handler', LiveKitWebhookController::class)->name('livekit_webhook'); Processing the Call We have a single action controller using the PHP SDK : WebhookReceiver <?php

namespace App\Http\Controllers;
use Illuminate\Http\Request;
use Agence104\LiveKit\WebhookReceiver;

class LiveKitWebhookController extends Controller {
    /**
     * Handle the incoming request.
     *
     * @param    \Illuminate\Http\Request  $request
     * @return  \Illuminate\Http\Response
     */
    public function __invoke(Request $request)
    {
        $content = $request->getContent(); 
        $header = $request->header('authorization');
        $receiver = new WebhookReceiver(env('LIVEKIT_API_KEY'), env('LIVEKIT_API_SECRET'));
        $data = $receiver->receive($content, $header);
        $event = $data->getEvent();

        switch($event)
        {
            case 'participant_joined':

            case 'participant_left':
        }
    }
} Front-End The front-end is a close integration of Livewire components that run on the server and Alpine.js that runs on the browser. Alpine.js integrates the LiveKit Client JS SDK to connect to rooms and publish and subscribe. We import LiveKit into : app.js import {
  connect,
  createLocalTracks,
  createLocalVideoTrack,
  createLocalAudioTrack,
  Room,
  RoomEvent,
  RemoteParticipant,
  RemoteTrackPublication,
  RemoteTrack,
  Participant,
  RoomOptions,
  VideoPresets,
  RoomConnectOptions,
  ParticipantEvent,
  MediaDeviceFailure,
  MediaDevicesError,
  MediaDevicesChanged,
  RoomMetadataChanged,
  Track,
  VideoQuality,
} from 'livekit-client'; The video and audio elements container sets the LiveKit configuration in the browser in , then initializes the device list and emits a event. x-data rendered <div class="py-4 bg-white" 
    x-data="av(true)" 
    x-init="acquireDeviceList(); $nextTick(() => { Livewire.emit('rendered') });" 
> The Livewire component, on receiving the event, runs code to check permissions and status of the auction and only then gets the access token and LiveKit URL for the connection and sends it to the browser with : dispatchBrowserEvent $this->set_user_access_token($this->auction, true);
$this->dispatchBrowserEvent('connect-live', [
    'url' => $this->livekit_url, 
    'token' => $this->livekit_access_token
]); The Alpine.js, on receiving the event, connects the room. connect-live @connect-live.window="(event) => connectToRoom(event.detail.url, 
event.detail.token, false)" The works via the Client JS SDK. connectToRoom Because we need the Livewire component to check certain conditions, such as if there is a live stream, we do not connect to the room automatically. We use to ensure that the component is rendered before sending the event to Livewire. This way, when Livewire dispatches an event to Alpine.js, the listener is active in the HTML. nextTick Connecting to A Room in JavaScript async connectToRoom(url, token, forceTURN) {
  this.token = token;
  this.url = url;

  const roomOptions = 
      this.isPublisher ?
      {
        adaptiveStream: true,
        dynacast: true,
        publishDefaults: {
          simulcast: true,
          videoSimulcastLayers: [
            VideoPresets.h90, 
            VideoPresets.h180, 
            VideoPresets.h216, 
            VideoPresets.h360, VideoPresets.h540
          ],
          videoCodec: this.selectedVideoCodec,
        },
        videoCaptureDefaults: {
          resolution: this.selectedVideoResolution.id,
        },
      }
      :
      {};

  const connectOptions = {
    autoSubscribe: true,
    publishOnly: undefined,
  };
  if (forceTURN) {
    connectOptions.rtcConfig = {
      iceTransportPolicy: 'relay',
    };
  }

  try {
    await room.connect(this.url, this.token, connectOptions);
    this.currentRoom = room;
    window.currentRoom = room;  
  } catch (error) {
    message = error;
    if (error.message) {
      message = error.message;
    }
    console.log('could not connect:', message);
  } finally {
    if (message) {
      Livewire.emit('connectionFailure');
    }

    return room;
} Publishing a Video await this.currentRoom?.localParticipant.setCameraEnabled(true);

const videoElm = this.$refs.video;

this.videoTrack = await createLocalVideoTrack();
this.videoTrack?.attach(videoElm); Subscribing to a Track Once the track is published, we render it: renderParticipant(participant) {

  const cameraPub = participant.getTrack(Track.Source.Camera);
  const micPub = participant.getTrack(Track.Source.Microphone);


  if (cameraPub) {

    const cameraEnabled = cameraPub && cameraPub.isSubscribed && 
       !cameraPub.isMuted;

    if (cameraEnabled) {
      const videoElm = this.$refs.video;
      this.attachTrack(cameraPub?.videoTrack, 'video');
    } 

  }

  if (micPub) {
    const micEnabled = micPub && micPub.isSubscribed && !micPub.isMuted;

    if (micEnabled) {
      const audioElm = this.$refs.audio;
      this.attachTrack(micPub?.audioTrack, 'audio');
    }      
  }

}, It was Tricky The integration involved a complicated interplay of server and client code. And the client code was an interplay of PHP and JavaScript. We love LiveKit and hope to carry this into production. So far, it was a single Docker container in a local environment. We have lots of work to do on the production setup. Also published . here

Implement Live Video Streaming in a Laravel PHP Web Application Using LiveKit

How to Build a Question and Answer Chatbot with Amazon Kendra and AWS Fargate

I've spent the last few weeks researching how to connect event busses in two different AWS accounts using the CDK. Most of the information that I've found has just been CloudFormation templates, which is fine, but some of the resources you have to create in CloudFormation are automatically created in the CDK. Now that I've solved the problem, I'd like to help the next unfortunate soul that needs to implement this. Fortunately, the final solution isn't that complicated. This article leaves out some boilerplate code, like creating the stacks. For the full source go to: . https://github.com/theBenForce/post-samples/tree/article/cross-account-event-bus What's needed? To get this to work you'll have to create a bus in each account—obviously. Beyond that, you'll need to create different resources for the sending and receiving accounts. In the receiving account, you'll need to create the rule that you want to be triggered by the message, and a policy on the target bus that allows messages from the sending account. In the sending account, you'll need to create an IAM Role that allows put events to the receiving bus. You'll also need to create a rule on the sending bus that references that role and forwards events to the receiving bus. Setting up the target account First, create the target bus. You'll need to set the name so that the ARN can be used in a stack in another account. const targetBus = new events.EventBus(this, "TargetBus", {
  eventBusName: "TargetBus"
}); Since we're going to be referencing this bus from another account, we need to tell the CDK to generate a physical name during the synthesis process. This enables the CDK to generate an ARN before deployment. targetBus._enableCrossEnvironment(); Now you need to create an event bus policy that allows messages from the source account. new events.CfnEventBusPolicy(this, "CrossAccountPolicy", {
  action: "events:PutEvents",
  eventBusName: targetBus.eventBusName,
  principal: sourceAccountId,
  statementId: AcceptFrom${sourceAccountId},
}); This wouldn't be any fun if you didn't get to see your events somewhere in the target account. To make that happen, create a CloudWatch log group that you can dump all of the received messages into. const eventLogs = new logs.LogGroup(this, "EventLogs", {
  logGroupName: "EventLogs",
}); Finally, you need to create the rule that you want to be triggered. The rule will pass all events with a set to into the log group that you created. detailType TestEvent new events.Rule(this, "TestRule", {
  eventBus: targetBus,
  eventPattern: {
    detailType: ["TestEvent"],
  },
	targets: [
    new eventsTargets.CloudWatchLogGroup(eventLogs),
  ],
}); Setting up the source account Start by creating the bus that will be sending events. const sourceBus = new events.EventBus(this, "SourceBus"); And create a rule that will forward TestEvent messages to the target bus. The CDK creates both the Event Bus Rule and an IAM Role that will allow your Event Bus to send messages to the target Event Bus. new events.Rule(this, "TestRule", {
	eventBus: sourceBus,
	eventPattern: "TestEvent",
	targets: [
		new eventsTargets.EventBus(targetBus)
	]
}); Deploy Now that you've created both busses, go ahead and deploy them. Without any fancy setup, you'll need to deploy the stacks one at a time using the proper AWS profile for each. npx cdk deploy --profile source SourceStack
npx cdk deploy --profile target TargetStack Testing Now that both stacks are deployed you can test the connection. Log into the source account's AWS console and navigate to "Event busses" in the EventBridge service. Select your bus then click Actions→Send events. On the page that opens, make sure the "Detail type" matches the value you used when you created the event bus rule. Now head over to your target account and open the CloudWatch log group that you created. You should see your message there. Summary Connecting event bridges across two AWS accounts requires several pieces to get it working, fortunately, the CDK makes it pretty simple to create them. In the target account, you need to create an Event Bus with an Event Bus Policy that allows messages from the source account. The source account needs an IAM Role attached to an Event Bus Rule, which the CDK takes care of behind the scenes. Also published on . https://thebenforce.com/post/cross-account-event-bus

Connecting Event Bridges Across AWS Accounts: A How-To Guide

Over the last decade, the growth and success of machine learning have been phenomenal, driven primarily by the availability of vast amounts of data and advanced computational power. This surge was brought about by the digitization of various sectors, leading to an explosion of digital data—everything from social media posts to online transactions and sensor data. Advances in machine learning techniques, particularly in deep learning, facilitated the development of more complex and versatile models. Consequently, machine learning applications have become ubiquitous, contributing to improved efficiencies and capabilities across numerous sectors, including healthcare, finance, and transportation. Working with these massive amounts of event-based data and deriving value from the events themselves and their context in time – other events happening nearby – is still difficult. Doing so in a real-time or streaming manner is harder still. You often must use complex, low-level APIs or work around the limitations of a higher-level query language designed to solve very different problems, like SQL. To tackle these challenges, we introduce a new abstraction for time-based data, called timelines. Timelines organize data by time and entity, offering an ideal structure for event-based data with an intuitive, graphical mental model. Timelines simplify reasoning about time by aligning your mental model with the problem domain, allowing you to focus on what to compute, rather than how to express it. In this post, we present timelines as a natural way to organize event-based data and extract value – directly, and as the inputs for machine learning and prompt engineering. We delve into the timeline concept, its interaction with external data stores (inputs and outputs), and the lifecycle of queries using timelines. This post is the first in a series about , an open-source event-processing engine designed around the timeline abstraction. We’ll follow up with an explanation of how Kaskada builds an expressive temporal query language on the timeline abstraction, how the timeline data model enables Kaskada to efficiently execute temporal queries, and, finally, how timelines enable Kaskada to execute incrementally over event streams. Kaskada Making sense of time Dealing with a large variety of events is difficult when treating each kind of event as a separate, unordered table of data – the way SQL views the world. It is difficult to understand what motivated Carla to make purchases, or what caused Aaron to engage with other users via messages. By organizing the data – by time and user – it becomes much easier to spot patterns. Aaron sends messages after winning. Carla makes purchases when frustrated by a series of losses. We also see that Brad may have stopped playing. By organizing the data – by time and user – it becomes much easier to spot patterns. Aaron sends messages after winning. Carla makes purchases when frustrated by a series of losses. We also see that Brad might have stopped playing. By organizing the events in a natural way – by time and user – we were able to identify patterns. This same organization allows us to express feature values computed from the events and use those to train and apply machine learning models or compute values to use within a prompt. The timeline abstraction Reasoning about time – for instance, cause-and-effect between events – requires more than just an unordered set of event data. For temporal queries, we need to include time as a first-class part of the abstraction. This allows reasoning about when an event happened and the ordering – and time – between events. Kaskada is built on the timeline abstraction: a multiset ordered by time and grouped by entity. Timelines have a natural visualization, shown below. Time is shown on the x-axis and the corresponding values on the y-axis. Consider purchase events from two people: Ben and Davor. These are shown as discrete points reflecting the time and amount of the purchase. We call these discrete timelines because they represent discrete points. The time axis of a timeline reflects the time of a computation’s result. For example, at any point in time we might ask “what is the sum of all purchases?” Aggregations over timelines are cumulative – as events are observed, the answer to the question changes. We call these continuous timelines because each value continues until the next change. Compared to SQL, timelines introduce two requirements: ordering by time and grouping by entity. While the SQL relation – an unordered multiset or bag – is useful for unordered data, the additional requirements of timelines make them ideal for reasoning about cause-and-effect. Timelines are to temporal data what relations are to static data. Adding these requirements mean that timelines are not a fit for every data processing task. Instead, they allow timelines to be a better fit for data processing tasks that work with events and time. In fact, most event streams (eg., Apache Kafka, Apache Pulsar, AWS Kinesis, etc.) provide ordering and partitioning by key. When thinking about events and time, you likely already picture something like a timeline. By matching the way you already think about time, timelines simplify reasoning about events and time. By building in the time and ordering requirements, the timeline abstraction allows temporal queries to intuitively express cause and effect. Using timelines for temporal queries Timelines are the abstraction used in Kaskada for building temporal queries, but data starts and ends outside of Kaskada. It is important to understand the flow of data from input, to timelines, and finally to output. Every query starts from one or more sources of input data. Each input – whether it is events arriving in a stream or stored in a table, or facts stored in a table – can be converted to a timeline without losing important context such as the time of each event. The query itself is expressed as a sequence of operations. Each operation creates a timeline from timelines. The result of the final operation is used as the result of the query. Thus, the query produces a timeline which may be either discrete or continuous. The result of a query is a timeline, which may be output to a sink. The rows written to the sink may be a history reflecting the changes within a timeline, or a snapshot reflecting the values at a specific point-in-time. Inputting timelines Before a query is performed, each input is mapped to a timeline. Every input – whether events from a stream or table or facts in a table – can be mapped to a timeline without losing the important temporal information, such as when events happened. Events become discrete timelines, with the value(s) from each event occurring at the time of the event. Facts become continuous timelines, reflecting the time during which each fact applied. By losslessly representing all kinds of temporal inputs, timelines allow queries to focus on the computation rather than the kind of input. Outputting timelines After executing a query, the resulting timeline must be output to an external system for consumption. The sink for each destination enables configuration of data writing, with specifics depending on the sink and the destination (see for more). this connector documentation There are several options for converting the timeline into rows of data, affecting the number of rows produced: Include the entire history of changes within a range or just a snapshot of the value at some point in time. Include only events (changes) occurring after a certain time in the output. Include only events (changes) up to a specific time in the output. A full history of changes helps visualize or identify patterns in user values over time. In contrast, a snapshot at a specific time is useful for online dashboards or classifying similar users. Including events after a certain time reduces output size when the destination already has data up to that time or when earlier points are irrelevant. This is particularly useful when re-running a query to materialize to a data store. Including events up to a specific time also limits output size and enables choosing a point-in-time snapshot. With incremental execution, selecting a time slightly earlier than the current time reduces late data processing. Both “changed since” and “up-to” options are especially useful with incremental execution, which we will discuss in an upcoming article. History The history – the set of all points in the timeline – is useful when you care about past points. For instance, this may be necessary to visualize or identify patterns in how the values for each user change over time. The history is particularly useful for outputting training examples to use for creating a model. Any timeline may be output as a history. For a discrete timeline, the history is the collection of events in the timeline. For a continuous timeline, the history contains the points at which a value changes – it is effectively a changelog. Snapshots A snapshot – the value for each entity at a specific point in time – is useful when you just care about the latest values. For instance, when updating a dashboard or populating a feature store for connecting to model serving. Any timeline may be output as a snapshot. For a discrete timeline, the snapshot includes rows for each event happening at that time. For a continuous timeline, the snapshot includes a row for each entity with that entity’s value at that time. Conclusion This blog post highlighted the importance of temporal features when creating ML models from event-based data. The time and temporal context of events is critical to seeing patterns in activity. This post introduced the timeline abstraction, which makes it possible to work with the events and the temporal context. Timelines organize data by time and entity, providing a more suitable structure for event-based data compared to multisets. The timeline abstraction is a natural progression in stream processing, allowing you to reason about time and cause-and-effect relationships more effectively. We also explored the flow of data in a temporal query, from input to output, and discussed the various options for outputting timelines to external systems. Rather than applying a tabular (static) query to a sequence of snapshots, Kaskada operates on the history (the change stream). This makes it natural to operate on the time between snapshots, rather than only on the data contained in the snapshot. Using timelines as the primary abstraction simplifies working with event-based data and allows for seamless transitions between streams and tables. You can experimenting with your own temporal queries today. and let us know what you think about the timeline abstraction. In an upcoming post, we’ll delve into the Kaskada query language and its capabilities in expressive temporal queries. get started Join the Slack community By Ben Chambers and Therapon Skoteiniotis, DataStax

Connecting Event-Based Data to Predictive AI in Real-Time

Conexión de datos basados en eventos a IA predictiva en tiempo real

Connecter les données basées sur les événements à l'IA prédictive en temps réel

रीयल-टाइम में ईवेंट-आधारित डेटा को प्रिडिक्टिव AI से कनेक्ट करना

イベントベースのデータをリアルタイムで予測 AI に接続する

Conectando dados baseados em eventos à IA preditiva em tempo real

Kết nối dữ liệu dựa trên sự kiện với AI dự đoán trong thời gian thực

将基于事件的数据实时连接到预测性 AI

Let's learn about via these 57 free stories. They are ordered by most time reading created on HackerNoon. Visit the to find the most read stories about any technology. Json /Learn Repo 1. Creating Developer-Friendly Data Services with Apache Cassandra Using data APIs and advanced data modeling will make it far easier for JSON-oriented developers to connect to Apache Cassandra. 2. Introducing Yet Another JWT Debugger Introducing a new JWT Debugger App - our way to contribute back to the developer community. The app is available on the web and as Desktop apps for Windows, Linux, and Mac. With JWT Debugger App we immediately highlight what really matters to you as a developer without any shenanigans. It is a very simple tool but we hope it will improve the developer experience. 3. How to Use .populate() With mongoDB How to use populate() method with mongoDB to itch data across referenced collections 4. How to Query Deeply Nested JSON Data in PSQL Recently I had to write a script, which should’ve changed some JSON data structure in a PSQL database. Here are some tricks I learned along the way. 5. How to Export Your HackerNoon Stories as a PDF The HackerNoon team is back at it with a new feature! You can now export your stories to a PDF or a JSON file. 6. The History of JSON and the People That Created It Douglas Crockford and Chip Morngingstar created the data exchange format that is now known as JSON. 7. Automate Simply With Webhook Automate anything with Webhook, a simple tool for your toolbox 8. With JSONB Data in PostgreSQL, You Can Get the Best of Both Worlds JSONB in PostgreSQL offers the best of relational and NoSQL. Here are two techniques that we use at AppLand to make JSONB data even more effective. 9. Custom Log Processor Integration – Fluentd vs Vector.dev By writing your tool, you gain more customization options, versatility, and other enhanced capabilities that can enrich your processing. 10. Defining Types: Using allOf in Swagger JSON Image by Devanath from Pixabay 11. 7 Kotlin Libraries Every Developer Should Know The most common Kotlin libraries that are used for cross-platform and Android development, testing, and documentation are considered in the article. 12. So, How are Observability and Monitoring Different, Actually? The similarities and differences between monitoring and observability and how to pair the two strategies 13. Ruby: How to read/write JSON File In Ruby read and write JSON file to hash can be achieved using File Handling. 14. How To Extract Key or Value From Hash in Ruby on Rails When I was recently working in one of the client projects, I had to
communicate with external MariaDB server to store records from
React/Rails app, that means I would get ActiveRecord hash from our app
which I had to convert to pure SQL query and send it to an external
server for storing. 15. A Quick Primer on Data Scraping Suppose you want to get large amounts of information from a website as quickly as possible. How can this be done? 16. Streamlining Form Validation with JSON Schema for Front-End and Back-End Efficiently validate forms with a single set of rules for both front-end and back-end using JSON Schema. 17. The Complete Microservice Tutorial: Introduction [Part 1] Project Link: https://github.com/Joker666/microservice-demo/ 18. An Interview with the Creator of JSON Douglas Crockford We had a nice chat with Douglas Crockford, a well-known American computer programmer who was involved in the development of the JavaScript language. 19. JSON Web Token: How To Secure Your Data With JWT A JSON Web Token (JWT) is an open standard (RFC 7519) that defines a way for securely transferring information between two parties. It can be used for an authentication system. As this information is digitally signed, it can be verified and trusted. 20. 8 Tips for Solving The JSON RPC Error In Metamask The most problem users come across is the internal JSON RPC error in Metamask. After a detailed search, I found there are numerous different solutions to it. 21. Hybrid Data Models: How To Have Your JSON Cake and Eat MariaDB Too By adding support for JSON, MariaDB provides the ultimate schema flexibility without sacrificing transactions or data integrity. 22. How To Do Data Mapping in Kumologica Data mapping is a key element in integration. Most of the prominent integration tools provide different capabilities for data mapping. In this article I thought of sharing on how data mapping can be achieved in Kumologica. Kumologica uses JSONata as the base for data mapping. JSONata is a Lightweight query and transformation language for JSON data. It supports complex queries expression which can be achieved with minimal syntax and has a location path semantics of Xpath 3.1. 23. How to Encode and Decode JSON with Scala-Circe Getting started with encoding and decoding JSON using Scala-Circe. 24. When Json Serializations Go Horribly Wrong From DateTime serialization issues, to the fact that serializing DateTime.MinValue causes a crash, because UTC time is less than minimal allowed DateTime value. 25. Fetch Data From a JSON File With a React & Redux App This guide explains how to use React and Redux to fetch data from JSON files in an easy and lightweight method through a real example and well explained steps. 26. Parsing JSON in C with Vely framework Parse JSON in C language with Vely framework 27. How to Use Data Science to Find the Best Seat in the Cinema (Part I) From the most popular seats to the most popular viewing times, we wanted to find out more about the movie trends in Singapore . So we created PopcornData — a website to get a glimpse of Singapore’s Movie trends — by scraping data, finding interesting insights, and visualizing them. 28. How To Query JSON in Couchbase via Collections and Scopes This week I’m attending the 3-day Couchbase Connect event and will be reporting on some of the topics that I find most interesting. 29. Extracting Information From Hash in Ruby on Rails When I was recently working in one of the client project, I had to communicate with external mariadb server to store records from react/rails app, that means I would get activerecord hash from our app which I had to convert to pure sql query and send it to external server for storing. If you have worked with sql queries previously then you must know that keys and values must be separated for insert operations like 30. Logging Vs. Monitoring: Best Practices for Logging [Part 2] Logging and Monitoring… this I tell you, brother. You can't have one without the other. 31. The Best Java Libraries that Every Developer Should Know This article describes Java libraries like Apache Commons, Guava, Log4j2, Logback, SLF4J, JUnit, TestNG, Mockito, Hamcrest, AssertJ, Jackson, Gson, JAXB, StAX 32. A Quick Guide to JSON Web Token [JWT] JSON Web Token (JWT) is an open standard (RFC 7519) for securely transmitting information between parties as JSON objects. 33. Improve Network API Performance For Your Apps Network APIs are everywhere in the modern world. If the data is the lifeblood of modern tech, then APIs are essentially vessels that carry it around distributed 34. Back-end Data and API Prototyping with Faker.js and JSON-Server Introduction 35. How to use Recursion to Traverse JSON Objects and the Filesystem I work primarily on application-level programs, so I tend to not use recursion very often. However, every now and then I need a function that is best solved recursively. It is important to be able to recognize when a problem is best solved recursively, and to be able to write it when the time comes. 36. Breaking Down MSON Template Queries Template Queries are dynamic templates constructed with MongoDB-style operators, which allow you to customize MSON components with less code. 37. Tree - AST Crushes JSON, XML, YAML, TOML, etc XML, JSON, TOML, YAML are bad relative to Tree data format 38. Debugging Gson, Moshi and Jackson JSON Frameworks in Production Parsing is a major source of production failures. Some are easy to track but some are insidious. Here's how you can debug them on the fly! 39. µjson — A minimal JSON parser and transformer in Go µjson is a minimal JSON parser and transformer that works on unstructured (and trusted) JSON. It works by parsing input and calling the given callback function when encountering each item. 40. Build Data-Driven Web App Without Backend During the last couple of decades websites' functionally has increased dramatically - from simple landing pages serving simple static ads to complex progressive web apps whose functionality close to native applications including user authorization, location tracking, bluetooth handling, and offline mode. 41. Using JSON Mapping to Work with APIs of Various Image Services Using JSON Mapping to Work with APIs of Various Image Services. This approach is applicable to any other services that are similar in type of returned results. 42. Coding 101: Who is Json? A.) Jason Voorhees (Friday the 13th) 43. Five Important Tips For Working With JWTs Nowadays, JSON Web Tokens are the most common way of proving identity information to APIs. The concepts behind JWTs are also quite easy to understand, and it takes only a couple of minutes to have the most basic authentication running. 44. Using Rainforest API With WordPress [A How-To Guide] Rainforest API is an alternative to the Amazon Product API provided to Amazon Associates. If you are thiking of building shopping comparisson sites with Amazon links and you don’t have an API key, or if you want to build a lot of pages very quickly without limitation, using Rainforest API is the answer. If you are serious about earning money as an Amazon Affiliate and want to make thousands of pages, do yourself a favor and start the project off right. 45. Writing Your First REST API: A How-to Guide As part of my Borum Jot project, I made a Web API for all my front-end platforms to create, retrieve, update, and delete (CRUD) data on the database. In this article, I'll discuss what exactly an API is and how I made my own Web API. 46. Today I Learned: Dealing with JSON DateTime when Unmarshal in Golang. Beware the date-time standard!! 47. What is SQL? And Where is it Used? What is SQL? Databases use it, query APIs use it, even energetic big data dashboards use it! Where did it come from and how are developers, DBAs, and app using. 48. Introducing Jdict Module in Python Providing attribute access to Python dictionary entries 49. 8 Most Popular Weather APIs for 2020 The climate is a hot issue and weather forecasting technology is suddenly cool. The urgent need for innovative weather and environmental conditions forecasting solutions is obvious whether you believe in climate change or not. 50. How to Win the Velo Writing Contest: A Detailed Cheat Sheet In order to display a non-static website - you'll need to have a data source and connect it with Velo. For example, you can create some sort of "fake API". 51. 3 Best Ways To Import JSON To Google Sheets [Ultimate Guide] 3 ways to pull JSON data into a Google Spreadsheet 52. How To Create a Simple Autocomplete Field And Connect it With Elasticsearch Autocomplete is a feature to predict the rest of a word a user is typing. It is an important feature to implement that can improve the user’s experience of your product. 53. How I'm Engineering a Versioned Database Storage Engine for Byte-Addressable NVM Feel free to contribute on GitHub 💚 54. JSON Web Auth Using Angular 8 and NodeJS The article is about interfacing an Angular 8 Project with a secure backend API. The Backend will be running on Node.JS. The security that will underlay the interfacing will be JSON Web Tokens. 55. Go: Handling JSON in MySQL 56. Querying Complex JSON Objects With SQL How many times have you run into a situation where you wish you could do a SQL join without getting duplicate rows back? What if we could get a list "column" returned instead? HarperDB’s ARRAY() function enables just that. In this post we’re going to take a look at a basic example of people with addresses and phone numbers. 57. Document Databases vs Relational Databases (Podcast Transcript) Amy Tom talks to Eric Bishard and Arun Vijayaraghavan about the differences between a Document Database and a Relational Database. Thank you for checking out the 57 most read stories about Json on HackerNoon. to find the most read stories about any technology. Visit the /Learn Repo

57 Stories To Learn About Json

As a seasoned tech entrepreneur, Ivan Mishanin co-founded and served as the CEO of Bright Box, a globally connected car software vendor, for over 8 years. The company reached a staggering $10M in annual revenue before being acquired by Zurich Insurance Group, which was ranked 79th in the Forbes rating. Global 2000 Currently, Ivan is the COO and co-founder at , a cutting-edge company revolutionizing the drug development process for depression and other psychiatric disorders. Brainify.AI In the interview, we discussed the challenges of being a tech entrepreneur and key strategies of transforming the company’s growth around the globe. Let’s talk about Bright Box. What market did you start with, and when? I established Bright Box in 2012 as an IT company that focuses on solutions and platforms in the connected car market. By the end of 2014, we were in the final stages of negotiations with a few Eastern European auto companies. We also managed to secure $1.5 million in investments from the LETA Capital venture fund. However, at the time, the Eastern European markets experienced a downturn that became a real issue for our business. To bounce back and find clients quickly, we leveraged all available channels, including networking through friends, participating in exhibitions, and attending conferences worldwide. At one such event, the Connected Cars conference in Amsterdam, we met potential partners from the Middle East, and after seven months, we won our first significant contract with Nissan in the region for three years and 45,000 cars. How did you transform the company once it started developing in other markets? As we began expanding into other markets, we had to transform the company in several ways to adapt to the unique challenges and requirements of each region. Here are some of the changes we made: Adjusting our team's schedule. Since the work week in the Middle East is from Sunday to Thursday, we adjusted our team's schedule to provide support on Sundays. This required some effort and incurred minor additional costs, but it was crucial for meeting our clients' expectations in the region. Adapting our product to the market. We began focusing more on achieving a better product-market fit by tailoring our product to the specific needs and demands of the new market. This involved understanding the unique preferences and requirements of local customers and adjusting our offerings accordingly. For instance, we added right-to-left writing and Arabic language support for the Middle East market, and we integrated Baidu Maps and the Chinese version of Microsoft Azure for the Chinese market. Restructuring the product team. As our growth continued, we realized that having a single product team for all regions was not feasible. To address this issue, we split the team into two parts: Core and Regional. The Core team was responsible for implementing technological and infrastructure changes that would simplify market adoption, while the Regional teams were responsible for catering to the specific needs of each country or region. Overcoming language barriers. Not all of our team members, including myself, spoke fluent English at that time, so we had to work on improving our language skills to facilitate effective communication in the international market. To improve my English, I began watching movies exclusively in English with subtitles during my flights, which helped me become familiar with conversational language. Additionally, I changed the language settings in all my operating systems and software to English and used a dictionary on my iPhone to look up unfamiliar words. I also started reading books in English, which helped me expand my vocabulary and grasp sentence structure. Traveling. In 2014-2015, I took around 100-120 flights per year to support our expansion efforts and maintain close communication with our teams across the globe. Learning about local culture and market needs. My team and I began investing more time in understanding the culture and specific needs of the market we were entering. This knowledge allowed us to better connect with our customers, partners, and stakeholders in the region and ultimately helped us succeed in our international expansion efforts. Wow, that’s a lot of traveling! What are a few crucial things you did when expanding Bright Box into new markets? Did you have to move to the country yourself? It's essential to prioritize and make some tough decisions. As a founder, you don't necessarily have to move to the country yourself. However, in my case, I decided that the success of the company was my top priority — even more important than my personal life or family. As a result, I made sacrifices in my personal life to focus on the company's growth. For many years, I didn't have a stable home. I lived out of my suitcase and occasionally spent weekends in an apartment. This level of commitment and dedication was necessary for me to ensure the success of our international expansion. To keep our team motivated and focused on the goals, I did everything I could to convey the importance of our work and why we needed to put in the extra effort. I believe that this motivation and a shared sense of purpose played a crucial role in our eventual success in expanding into new markets. In 2017, Zurich Insurance Group acquired your company, Bright Box, for $75M. Can you share some of your experience of how it feels to grow your company from scratch and be able to sell it to one of the largest companies in the world? As the ex-founder and ex-CEO of Bright Box, I can attest to the fact that building a company from scratch and eventually selling it to a global giant like Zurich Insurance Group for $75 million in 2017 was an emotional rollercoaster filled with unique experiences and valuable lessons. Initially, I was over the moon with excitement, knowing that all the hard work had paid off and our company was being acquired by an industry leader. However, this excitement was soon followed by a profound sense of loss and emptiness. It felt like I had given away a part of myself, something I had nurtured and grown from the ground up. The realization that I was no longer in complete control of my "baby" hit hard and left me feeling adrift for some time. After the acquisition, I found myself in a familiar yet changed role. While I continued as the CEO of the company, my decision-making power was reduced, and the ability to make bold moves to propel the company forward quickly became more limited. Nevertheless, I believe that selling your company can be the right decision and a new chapter in your life. Based on my experience, I would like to offer the following advice to those who aspire to a successful exit: Embrace change: Understand that selling your company is a significant milestone and the start of a new phase in your life. You may venture into new industries or explore new spaces, but remember that your experience as a founder will always stay with you. Be prepared for a shift in dynamics: As a founder, you're used to having control and making critical decisions. However, after an acquisition, you may need to adapt to a new corporate structure where you have less autonomy. Prepare yourself mentally for this transition. Negotiate a reasonable transition period: When selling your company, try to avoid a lengthy transition period. As a founder, your entrepreneurial spirit might not align with the role of an employee, even if it's at the company you founded. Ensure that the terms of the acquisition allow you to move on to new ventures in a timely manner. In conclusion, selling a company can be a bittersweet experience, filled with emotional highs and lows. Embrace the change, learn from the experience, and continue to innovate as you embark on your next entrepreneurial journey. Let’s talk a bit about your current project, a deep tech startup, Brainify.AI? How did the idea come about? In 2020, I experienced depression firsthand and was taken aback by the subjective nature of psychiatry. When you have chest pain, a doctor will scan your heart and conduct blood tests, but no one was able to scan my brain. My co-founder Mariam, a neuroscientist from Harvard, had pitched the idea of precision psychiatry to me earlier, but it didn't resonate with me at the time. However, once I went through depression and started feeling better, I immediately recognized the huge need for a more objective approach to mental health. Brainify.AI is an AI/ML electroencephalography (EEG) biomarker platform for depression treatment response prediction that increases the likelihood of new drug approval by 80% and reduces R&D costs. Our products, PlaceboInsight AI, TherapyInsight AI, and CleanSpectrum AI, are designed to enhance the efficiency of clinical trials and improve patient outcomes. We identify biomarkers that predict treatment response during clinical phase 2, use them to select patients for clinical phase 3 trials, and predict placebo response in phase 2 and phase 3 to increase the likelihood of drug approval. Brainify.AI’s long-term goal is to be the go-to biomarker platform for drug development and in-clinic diagnostics. Our product relies on two decades of scientific research in psychiatry, neuroscience, and psychopharmacology. Like many other scientists, we want to be able to recommend the best treatment approach for different groups of patients. However, most importantly, we want to identify “state-markers,” which can be used as the indicator of the treatment results and patient state. By predicting treatment responses, Brainify.AI can become the go-to biomarker platform for drug development and in-clinic diagnostics, ultimately impacting over one billion people affected by psychiatric disorders worldwide. To achieve this goal, we are collaborating with scientists from institutions like Harvard Medical School, Cornell University, Massachusetts General Hospital, and Northwell Health. What are the next goals for Brainify.AI? As we accumulate more data and refine our algorithms, we can expect a future where mental health treatment is no longer a one-size-fits-all approach, but rather a highly personalized experience designed to maximize recovery and overall well-being. Companion diagnostics have proven to be incredibly effective in oncology, and I expect to see the same situation play out in CNS over the next 10 years. We are now at the forefront of this shift toward personalized medicine in mental health. Our cutting-edge AI and machine learning techniques allow us to develop innovative solutions that can help people lead happier and healthier lives. This revolution in care will not only increase the success rate of depression treatments but also offer hope and a better quality of life to millions of people around the globe. We are excited to be a part of this journey and look forward to the advancements yet to come.

From Connected Cars to Mental Health: Ivan Mishanin's Journey as a Co-Founder and Tech Leader

WebSockets are a technology for creating real-time, bi-directional communication channels over a single TCP connection. They help build applications that require low-latency, high-frequency communication, such as chat applications, online gaming, and collaborative software. In this tutorial, we will be building a real-time chat application using WebSockets and the Socket.IO library. We will use Node.js as the server-side language and React as the client-side technology. However, the principles discussed in this tutorial can be applied to any language or technology that supports WebSockets. Prerequisites Before we begin, you should have the following prerequisites: Basic understanding of JavaScript Basic understanding of Node.js and React Basic understanding of web development concepts, such as HTTP and HTML Node.js and npm installed on your machine React developer tools installed in your browser (optional, but helpful for debugging) Setting up the Server First, let's create a new directory for our project and navigate to it in the terminal. mkdir real-time-chat-app
cd real-time-chat-app Next, let's create a new Node.js project by running the following command: npm init -y This will create a file in our project directory. package.json Next, we need to install the Socket.IO library, which will handle the WebSocket communication for us. Run the following command to install it: npm install socket.io Now let's create a new file called in the root of our project directory. This will be the entry point for our server-side code. server.js In , we first need to require the and modules: server.js HTTP socket.io const http = require('http');
const io = require('socket.io'); Next, let's create an HTTP server and bind it to a port. We will use port 3000 for this example, but you can choose any available port on your machine. const server = http.createServer((req, res) => { res.end('Server is running!');
});
const port = 3000;
server.listen(port, () => {
  console.log(`Server is listening on port ${port}`);
}); Now if we run the server by running in the terminal and navigate to in the browser, we should see the message "Server is running!". node server.js http://localhost:3000 Next, we need to attach the Socket.IO server to our HTTP server. We do this by calling the method on the object, and passing it to our HTTP server as an argument: listen io const ioServer = io.listen(server); Now that we have set up the server, let's move on to setting up the client-side code. Setting up the Client First, let's create a new directory called in the root of our project directory. This is where we will store the client-side code for our chat application. client Next, let's create a new React project in the directory. Run the following command in the directory: client client npm start Once you have created a new React project in the directory, you should have a and directory inside the directory. client public src client Inside the directory, create a new file called . This will be the root component of our chat application. src App.js First, let's import the required dependencies: import React, { useState, useEffect } from 'react'; import io from 'socket.io-client'; Next, let's create a function called that will handle the WebSocket communication for us. useWebSocket This function will return an object with three properties: : an array of messages that have been received from the server messages : a function that can be called to send a message to the server sendMessage : an error object that will be set if there is an error in the WebSocket connection error Add the following code to : App.js function useWebSocket() {   const [messages, setMessages] = useState([]);   const [error, setError] = useState(null);   useEffect(() => {     const socket = io('http://localhost:3000');     socket.on('connect', () => {       console.log('Connected to server!');     });     socket.on('disconnect', () => {       console.log('Disconnected from server');     });     socket.on('error', (error) => {       setError(error);     });     socket.on('message', (message) => {       setMessages((prevMessages) => [...prevMessages, message]);     });     return () => {       socket.disconnect();     };   }, []);   const sendMessage = (message) => {     if (socket.connected) {       socket.send(message);     }   };   return { messages, sendMessage, error }; } This code uses the hook to set up the WebSocket connection when the component mounts. We are also using the hook to keep track of the and state. useEffect useState messages error The function returns an object that contains the array, the function, and the object. useWebSocket messages sendMessage error Now let's use the function in our component. Add the following code to : useWebSocket App App.js function App() {
   const { messages, sendMessage, error } = useWebSocket();   if (error) {     return <div>Error: {error.message}</div>;   }   return (     <div>       <ul>         {messages.map((message) => (           <li>{message}</li>         ))}       </ul>       <form onSubmit={(event) => {         event.preventDefault();         const messageInput = event.target.elements.message;         sendMessage(messageInput.value);         messageInput.value = '';       }}>         <input name="message" />         <button type="submit">Send</button> function App() {   const { messages, sendMessage, error } = useWebSocket();   if (error) {     return <div>Error: {error.message}</div>;   }   return (     <div>       <ul>         {messages.map((message) => (           <li>{message}</li>         ))}       </ul>       <form onSubmit={(event) => {         event.preventDefault();         const messageInput = event.target.elements.message;         sendMessage(messageInput.value);         messageInput.value = '';       }}>         <input name="message" />         <button type="submit">Send</button>       </form>     </div>   ); }
 export default App; Now let's move on to handling the messages on the server side. Handling Messages on the Server In the file, let's add the following code to handle incoming messages: server.js ioServer.on('connection', (socket) => {   console.log('New client connected');   socket.on('message', (message) => {     console.log(`Received message from client: ${message}`);     ioServer.emit('message', message);   });   socket.on('disconnect', () => {     console.log('Client disconnected');   }); }); In this code, we use the connection event to handle new clients connecting to the server. We are also using the event to handle incoming messages from the client and the event to handle clients that disconnect from the server. message disconnect When a message is received, we simply log it to the console and then emit it back to all connected clients using the method. emit Now, if you start the server by running and navigate to in the browser, you should be able to send messages and see them displayed in real-time. node server.js http://localhost:3000 Conclusion This tutorial taught us how to create a real-time chat application using WebSockets and the Socket.IO library. We have set up a Node.js server and a React client and implemented the WebSocket communication using the hook on the client side and the , , and events on the server side. useWebSocket connection message disconnect You can extend this application in many ways, such as adding user authentication, storing messages in a database, and implementing more advanced features like message editing and deletion. I hope this tutorial has provided a good foundation for you to build on. Helpful Resources Microsoft websockets Basics of Websockets Also published here.

EVENT CONNECT

eventconnect.it

-- employees

Since n.d.

COMPANY RANKING

EVENT CONNECT

EVERGREEN INDEX #3759

Representing this company? Click here to claim and customize this page!

Event Connect WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!

EVENT CONNECT

eventconnect.it

-- employees

Since n.d.

COMPANY RANKING

EVENT CONNECT

EVERGREEN INDEX #3759

RELATED COMPANIESRANK

STORIES ABOUT EVENT CONNECT

Representing this company? Click here to claim and customize this page!

Event Connect WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!