EV Connect

evconnect

We shall create a Bot in which aware of Batch Presence change event. Slack Go Essentially we are going to build and run the example given here: . This tutorial give a more detailed actions of how to make it run, so that even a relatively new can follow this easily. https://github.com/nlopes/slack/blob/master/examples/connparams/connparams.go An examples of presence change event is when a member of the chat group changes their status from active into away. Slack provides an to their API for a more efficient presence change detection, by having it in a batch. This is in accordance to proliferation of groups with large members in Slack, where changes of presence could resulting in expensive handling of many events at a short period of time, or at the cost of missing some of the event. update In this tutorial we consider that a Golang has been installed. You can also refer to for such purpose. https://golang.org/doc/install For a more clear step by step activities, we can refer to commits of . https://github.com/suekto-andreas/tutorial-go/commits/TUT-001 How can this base code be expanded Out of the code created by following this tutorial, you can expand it into a more complex bot, one of the very preliminary extension can be happened at creating Handlers into the event. (This tutorial is just simply doing print.) Not too mention once you generates Handlers and creating a more complex business process / use cases, takes care of the package oriented design, provides automated unit testing. I personally prefer the concept of treating a Go project like a library, while the executable is grouped inside directory. cmd Create Slack Token First we need the token for accessing the API. Please refer to the following link to do so : https://get.slack.help/hc/en-us/articles/215770388-Create-and-regenerate-API-tokens Get the Dependencies We are using the following library to communicate with Slack : . Let’s go get it, run the following command in terminal https://github.com/nlopes/slack $ go get github.com/nlopes/slack Create our Project Directory For this purpose, as we simply create a command line to be executable, I structured this as following: this tutorial project structure When you are aiming for building a specific slack bot project, you might prefer a less hierarchy here, as the above structure is prepared for more tutorial codes to be put under 1 repository. An example would be that the become the root project directory, instead of . batchaware tutorial-go Write the Code Our code shall be a simple main function. First of all let’s instantiate a Slack object. Replace “YOUR TOKEN HERE” with the one we created in the previous step. (If you are considering a production code, ensure that token here is provided in a better way, not hard coded, put it for example as ENVIRONMENT variable.) package main import ("fmt""log""net/url""os" "github.com/nlopes/slack") func main() {api := slack.New("YOUR TOKEN HERE",slack.OptionDebug(true),slack.OptionLog(log.New(os.Stdout, "slack-bot: ",log.Lshortfile|log.LstdFlags)),)} Next is for us to establish an RTM (Real Time Messaging) connection with Slack. Here is we pass in the Option parameter that indicates our Bot is ready for batch presence aware. rtm := api.NewRTM(slack.RTMOptionConnParams(url.Values{"batch_presence_aware": {"1"}})) Let’s start the connection go rtm.ManageConnection() Afterward we can listen to even by looking at the IncomingEvents channel, using the following for loop for msg := range rtm.IncomingEvents {fmt.Print("Event Received: ")} We are going to send hello world to the channel where we want our bot to be listening to. We use the ConnectedEvent to do this, this is an internal event of the library, not a Slack event. Upon this event we SendMessage which indicates the corresponding Slack Channel ID, we want the Bot listening to. for msg := range rtm.IncomingEvents {fmt.Print("Event Received: ") switch ev := msg.Data.(type) {  
case \*slack.ConnectedEvent:  
    fmt.Println("Infos:", ev.Info)  
    fmt.Println("Connection counter:", ev.ConnectionCount)  
    // Replace ABCDEFGH with your Channel ID  
    rtm.SendMessage(  
        rtm.NewOutgoingMessage("Hello world", "ABCDEFGH"))

default:  
    // Ignore other events..  
    fmt.Printf("Unexpected: %v\\n", msg.Data) }} To activate presence change event we need to first subscribe for this event (it’s a mandatory step since Jan 2018.) We going to subscribe during HelloEvent, which is a Slack event when the Bot has successfully connected. For this step we need USER-IDs, a simple way to retrieve some of this can be done by following this step . (For a more automated way, the following could inspired you.) here link for msg := range rtm.IncomingEvents {fmt.Print("Event Received: ") switch ev := msg.Data.(type) {  
case \*slack.ConnectedEvent:  
    fmt.Println("Infos:", ev.Info)  
    fmt.Println("Connection counter:", ev.ConnectionCount)  
    // Replace ABCDEFGH with your Channel ID  
    rtm.SendMessage(  
        rtm.NewOutgoingMessage("Hello world", "ABCDEFGH"))

case \*slack.HelloEvent:  
    fmt.Printf("Hello: %v\\n", ev)  
    // Replace USER-ID-N here with your User IDs  
    rtm.SendMessage(rtm.NewSubscribeUserPresence(\[\]string{  
        "USER-ID-1",  
        "USER-ID-2",  
    }))

default:  
    // Ignore other events..  
    fmt.Printf("Unexpected: %v\\n", msg.Data)  
} } After all is set and done, we now shall listen to our main target in this article, the presence change event ! for msg := range rtm.IncomingEvents {fmt.Print("Event Received: ") switch ev := msg.Data.(type) {  
case \*slack.ConnectedEvent:  
    fmt.Println("Infos:", ev.Info)  
    fmt.Println("Connection counter:", ev.ConnectionCount)  
    // Replace ABCDEFGH with your Channel ID  
    rtm.SendMessage(  
        rtm.NewOutgoingMessage("Hello world", "ABCDEFGH"))

case \*slack.HelloEvent:  
    fmt.Printf("Hello: %v\\n", ev)  
    // Replace USER-ID-N here with your User IDs  
    rtm.SendMessage(rtm.NewSubscribeUserPresence(\[\]string{  
        "USER-ID-1",  
        "USER-ID-2",  
    }))  
  
case \*slack.PresenceChangeEvent:  
   fmt.Printf("Presence Change: %v\\n", ev)

default:  
    // Ignore other events..  
    fmt.Printf("Unexpected: %v\\n", msg.Data)  
} } Run the Bot To run the bot (given the directory structure as is in this tutorial) $ go run slacktut/batchaware/cmd/batchaware.go Then the bot shall start listening into the Slack Channel. Try by making a member in the channel to change its presence (like from active to away.) switch ev := msg.Data.(type) {case *slack.ConnectedEvent:fmt.Println("Infos:", ev.Info)fmt.Println("Connection counter:", ev.ConnectionCount)// Replace ABCDEFGH with your Channel IDrtm.SendMessage(rtm.NewOutgoingMessage("Hello world", "ABCDEFGH")) case *slack.HelloEvent:fmt.Printf("Hello: %v\n", ev)// Replace USER-ID-N here with your User IDsrtm.SendMessage(rtm.NewSubscribeUserPresence([]string{"USER-ID-1","USER-ID-2",})) default:// Ignore other events..fmt.Printf("Unexpected: %v\n", msg.Data)}}

Slack’n Go: Batch Presence Aware Bot

How to Solve the Microsoft.Data.SqlClient.SqlException (0x80131904): Incorrect syntax near '$ Error

Programmers often need to run some recurring process automatically at fixed intervals or at specific times. A common solution for this problem is to use a cron job. When you have full access to your own server, configuring cron jobs is quite straightforward. However, how hard is it to configure cron jobs when you use an application hosting service? Some services, thankfully, provide a way for you to do this. In this article, we’ll walk through a sample mini-project that shows how to easily set up and deploy a cron job on . Render Core Concepts What Is a Cron Job? A cron job is a Unix command that runs as a background process on a schedule determined by a . Generally, cron determines the jobs to run via crontab configuration files, which consist of pairs of cron expressions and corresponding commands. cron Cron Expression What Is Render? Render is a cloud application hosting service that offers a variety of web service hosting solutions, such as static sites, web servers, databases, and, yes, even cron jobs! Render handles the hassle of hosting and deployment for you so that you can spend all of your time focusing on building out your projects. What Are Render Cron Jobs? Render offers a cron job hosting service that simplifies the process of deploying and maintaining a cron job in the cloud. To set up a Render cron job service, simply link a GitHub repo, choose a runtime, and provide the command to run and the cron expression to determine the schedule. Overview of Our Mini-Project Our project will be a simple service that lets us create and store notes. The service also runs an hourly cron job to email us all the notes created in the last hour. The application consists of three parts: An Express web server that handles requests to create the notes A PostgreSQL database to store the notes A cron job that sends the notes digest email We'll use Render services for each of these components. We'll also use as the service for sending out emails. For our Node.js application, we’ll add the following dependency packages: Mailjet to interact with the database pg as a quality-of-life upgrade that allows us to use async functions as our Express handlers express-async-handler , which is the official client library that interacts with the Mailjet API node-mailjet We’ll assume that you have on your development machine. In our demo code, we’ll use for our package manager. Node.js installed Yarn Setting Up the Project Repo Let's start by setting up our project repo and our web service on Render. We can fork Render's Express Hello World repo for our initial . Express server boilerplate code In Render, we that uses the forked repo. create a web service page We enter a name for our web service, and we proceed with all of the default values. After Render finishes deploying, we see a service URL. We can visit that URL in our browser to verify that everything was set up correctly. Now, we can clone the forked repo to our development machine, and then add our dependencies: ~/project$ yarn add pg express-async-handler node-mailjet With our initial project repo set up, let’s move on to setting up our database. Setting Up the Database Our database is very simple, consisting of just one table called notes. The table will have a column to store the note text and another column to store the timestamp when the note was created. We’ll on Render. create a PostgreSQL database service We provide a name for the database service and then use the default values for all other options. After creating the database, we can connect to it from our local machine and create the table. Copy the connection string from the database dashboard, and then start up a in your local project directory. We'll use a to make the query to our database, so we'll need to import the class and create a object with our external connection string: notes external node REPL connection pool Pool Pool const { Pool } = require('pg');
const pool = new Pool(
  { connectionString: '<External Connection String>?ssl=true'}
); Note that since we are connecting through SSL in the REPL, we need to append to the end of the connection string. With our pool object created, we can execute the query to create the table: node ?ssl=true pool.query(
  'CREATE TABLE notes (text text, created timestamp);',
  console.log
); Voila! Our database is set up with our table! notes Setting Up an Environment Group in Render Before we add the functionality to our web service to start populating the table, let's make sure that our web service has access to our database. In fact, because both our web service and cron job will need to connect to the database, we can take advantage of Render's environment groups to create a shared group of environment variables that we can use for both services. To do this, we'll want the connection string from the database dashboard, since both the web service and cron job will communicate with the database through Render’s internal network. Click on in the main Render navigation. internal Env Groups Next, click on . New Environment Group Choose a name for your environment group. Then, add a new variable with a key of , and paste the internal connection string as the value (no need for this time). CONNECTION_STRING ssl=true Once you've created the group, you can go back to the settings for the web service. In the section, you can select the environment group you just created, and click on . Now, our Node.js code can access any variables we define in this group through the global object. We’ll see an example of this as we start to build out our Express app. Let’s do that now! Environments Linked Environment Groups Link process.env Creating the Express App Our Express app will only have one endpoint, , where we'll handle and requests. /notes POST GET When we receive a request, we create a new note row in the database. We'll expect the of the request to be and the body to be formatted as . We'll also note the time of the request and store that timestamp as the note's value. POST Content-Type application/json {"note": "<note text>"} created When we receive a request, we'll query the database for all the notes and return them as a JSON response. GET Let's start by getting rid of all of the unnecessary code from our boilerplate. We only need to keep the following lines, and we change the callback slightly: app.listen const express = require('express');
const app = express();
const port = process.env.PORT || 3001;

app.listen(port, () => console.log(`Notes server listening on port ${port}!`)); Next, let's add all of the imports we'll need. Again we’ll use a connection to connect to the database: Pool const { Pool } = require('pg'); Additionally, we’ll make use of the package: express-async-handler const asyncHandler = require('express-async-handler'); We instantiate our with the environment variable: Pool CONNECTION_STRING const connectionString = process.env.CONNECTION_STRING;
const pool = new Pool({connectionString}); Since we're expecting a JSON request, let's also use , which will parse the request body into a JavaScript object that we can access at : POST JSON middleware from Express req.body app.use(express.json()); Handling Requests GET /notes Now we can get into the meat of our app: the request handlers. We'll start with our handler since it's a bit simpler. Let’s show the code first, and then we’ll explain what we’ve done. GET app.get('/notes', asyncHandler(async (req, res) => {
  const result = await pool.query('SELECT * FROM notes;');
  res.json({ notes: result.rows });
})); First, we register an async function with at the endpoint using . In the body of the callback, we want to select all the notes in the database using . We return a JSON response with all of the rows we received from the database. asyncHandler /notes app.get pool.query And that's all we need for the handler! GET At this point, we can commit and push these changes. Render automatically builds and redeploys our updated application. We can verify that our handler works, but for now, all we see is a sad, empty notes object. GET Handling Requests POST /notes Let's move on to our handler so that we can start populating our database with some notes! Our code looks like this: POST app.post('/notes', asyncHandler(async (req, res) => {
  const query = {
    text: 'INSERT INTO notes VALUES ($1, $2);',
    values: [req.body.note, new Date()],
  };
  await pool.query(query);
  res.sendStatus(200);
})); First, we insert a new row into our database with our note text and creation timestamp. We get the note text from , and we use to get the current time. The object is converted into a PostgreSQL data type through our use of . We send the insert query, and then we return a response. req.body.note new Date() Date parameterized queries 200 Deploy and Test After pushing our code and having Render redeploy, we can test our server by sending some test requests. At the command line, we use : curl curl -X POST <INSERT WEB SERVICE URL>/notes \
     -H 'Content-Type: application/json' \
     -d '{"note": "<INSERT NOTE TEXT>"}' You can then visit the endpoint in your browser to see all of your newly created notes! /notes Creating the Cron Job The last component that ties our project together is the cron job. This cron job will run at the top of every hour, emailing us with all the notes created in the last hour. Set Up Mailjet We’ll use Mailjet as our email delivery service. You can sign up for a free account . here You’ll need your Mailjet API key and secret key from the API key management page. Let's add these keys to the environment group we created earlier. Add the following environment variables: MAILJET_APIKEY MAILJET_SECRET : the name of the email recipient (your name) USER_NAME : the email address of the recipient (your email address) USER_EMAIL Implement Cron Job Script Now let's write the script we'll run as the cron job, which we can call . Again, we'll use a to query our database, and we'll also want to initialize our Mailjet client with our environment variables: mail_latest_notes.js Pool const { Pool } = require('pg');
const mailjet = require ('node-mailjet')
  .connect(process.env.MAILJET_APIKEY, process.env.MAILJET_SECRET);
const connectionString = process.env.CONNECTION_STRING;
const pool = new Pool({connectionString}); Next, let's query the database for all notes created in the last hour. Since this will be an asynchronous operation, we can wrap the rest of the script in an , which will allow us to use the keyword to make it easier to work with: async IIFE await (async () => {
  // all remaining code will go here
})(); We use another parameterized query with to capture the current time and use it to filter the notes. This time, however, we'll want to get the time an hour before the current time, which we can do using the and Date methods, so that we can filter for all the notes after that timestamp: new Date() setHours getHours const timestamp = new Date();
timestamp.setHours(timestamp.getHours() - 1);
const query = {
  text: 'SELECT * FROM notes WHERE created >= $1;',
  values: [timestamp],
};
const result = await pool.query(query); We check how many rows were returned, and we won’t send the email if there aren’t any notes to send. if (result.rows.length === 0) {
  console.log('No latest notes');
  process.exit();
} If there are rows, then we create the email message with the retrieved notes. We pull out the text from each note row with a and use HTML for some easy formatting, joining all the note texts with tags: map <br> const emailMessage = result.rows.map(note => note.text).join('<br>'); Finally, we use the Mailjet client to with the message we just created and the environment variables we set up earlier. We can also log the response we get back from Mailjet, just to make sure that our email was sent: send an email const mailjetResponse = mailjet
  .post('send', {'version': 'v3.1'})
  .request({
    'Messages':[{
      'From': {
        'Email': process.env.USER_EMAIL,
        'Name': process.env.USER_NAME
      },
      'To': [{
        'Email': process.env.USER_EMAIL,
        'Name': process.env.USER_NAME
      }],
      'Subject': 'Latest Notes',
      'HTMLPart': `<p>${emailMessage}</p>`
    }]
  });

console.log(mailjetResponse); That's all we need for our script! Set Up Render Cron Job Service Lastly, let's create the cron job service on Render. We give our cron job service a name and set the environment to . Then, we set the command field to . To run the script every hour, we set the schedule field to the cron expression . Render has a nifty label under the input which shows what the cron expression translates to in plain English. We create the cron job. Node node mail_latest_notes.js 0 * * * * Next, we go to the tab for the cron job service, and we link the environment group that we created earlier. All that's left to do is wait for Render to finish building our cron job service. Then, we can test it! Before the build finishes, you can create more notes to make sure the script sends an email. Finally, you can click on the button on the cron dashboard to manually run the script, and check your inbox to make sure you receive that email. Environment Trigger Run And with that, we've finished our notes project! Conclusion Job schedulers like are powerful tools that provide a simple interface to run automated processes on strict schedules. Some application hosting services — like Render — make it easy for you to set up cron job services alongside your web and database services. In this article, we walked through how to do just that, by building a mini-project that saves notes and then sends an email digest triggered hourly by a cron job. With Render, coordinating communication between our various components and setting up the cron job was straightforward and simple. cron Happy coding! Also Published Here

Scheduled Cron Jobs with Render

Types Of Medical Databases And Their Benefits For Humanity

How to Build a High-Performance TCP Server from Scratch

has exited the cryptocurrency market. It’s volatility was able to guarantee up to 40% interest every month and 0.25% daily interest back for your investment if you invest over $10,010. Based on these claims, BitConnect was saying for your $10,010 investment, you will gain $25.025 per day ($750.75 every 30 days) just from the daily interest rate guarantee. Then, take into consideration their vaguely defined “proprietary software” that guarantees returns (and never have any losses in its trading algorithm, regardless of market behavior) and you’ve got yourself a major . BitConnect software red flag Generally speaking, if it’s too good to be true, it probably is. Identifying Ponzi Schemes At the very center of every classic Ponzi scheme are two things: an investment with (allegedly) a remarkably high return, and a story about just why the extraordinary returns can be so easily achieved. When any time of investment promises a guaranteed compounded monthly return (in this case, almost up to 40% return a month), you can pretty much guarantee you are in trouble. Here are several key signs you might be in a scheme: You never receive any real collateral for your investment (or in this case, cryptocurrency), just a promise that you will earn money back The guaranteed return of your investment is way too good to be true (should be noted that Charles Ponzi (original con-artist) promised 50 percent and sometimes even 100 percent rates of return) — sound familiar for BitConnect? You’re told a complicated yet convincing reason about why the returns are so strong (in this case, a “proprietary trading algorithm”) How to Protect Yourself in the Future It’s very unfortunate that there are individuals out there who would take advantage of others but there are ways to protect yourself in the future! These are some steps to take before you invest: Do your due diligence by researching the individual offering you the product and the company too — do they seem reputable? Do they have history of success? Are they truly who they say they are? Especially in the cryptocurrency world where people are hiding behind aliases. Ask yourself — what are you getting in return for your money? Are you getting any type of collateral for your money? Finally, please don’t let your greed cloud your good judgment. If alarm bells are going off in your head, don’t ignore them — listen to yourself & find something else to invest in. Preventing the Next Major Mt. Gox Many people learned the hard way with the recent BitConnect fraud and to help prevent that, I’ve compiled a list of what appears to be other world so you can protect yourself (and your friends) from fraud: Ponzi/Pyramid schemes that already exist in the cryptocurrency Binary Coin ( ) — here is what Binary Coin promises: https://binarycoin.io/ Screenshot directly from their promotional YouTube Video Seem familiar? 2. Bitfinite ( ) — they are guaranteeing even high returns than BitConnect… https://www.bitfinite.co/ Screenshot directly from Bitfinite website 3. EthConnect ( ) — guaranteeing up to 45% return, with 0.2% daily return https://ethconnect.com/ Screenshot directly from EthEconnect website 4. Gold Reward ( ) — now guaranteeing up to https://goldreward.io/ 45% PER MONTH Screenshot directly from Gold Reward Website And the list goes on… ExacoinFalcon CoinFicoinForzacoinGoldgateHextracoinIdeacoinKnox CoinLendconnectLoopXMartcoinMoneroconnectMonetize CoinMonyxNeoconnectPagarexRegalcoinSecular CoinTEX CoinWestern Coin The ridiculous thing is…these are just the ones I’ve found through a quick Google search in relation to cryptocurrency lending platforms. I hope this list will help some of you in the future. Protect yourselves out there in the wild west of cryptocurrency!

Don’t fall for another BitConnect — key steps to take before you invest in cryptocurrency

Despite my affinity for new technologies, using instant messaging at work has always struck me as counterproductive. Whether it’s Slack, Microsoft Teams, or similar solutions, the apparent benefits of these tools seem to come at the expense of overall . productivity These apps, combined with our dependence on smartphones, have redefined the rules of communication at work. It’s almost impossible to get away from them since they follow us everywhere, comfortably tucked in our pockets. The result: constant connectivity has become the default work culture. Employees are expected to read and respond to messages immediately or be penalized. Yet, the culture of connectivity is one of the main causes of distraction in the workplace. As far as I’m concerned, constant connectivity is counterproductive, and I will prove it to you. When connectivity becomes counterproductive People working in professional services (consultants, financial services, accountants, lawyers, etc.) are particularly affected by the culture of constant connectivity. It’s commonplace in these circles to think that being constantly available to the client is proof of professionalism and quality of service. Yet the relationship between constant connectivity and quality of work has never been proven. To verify this, two American researchers, Leslie A. Perlow and Jessica L. Porter, , one of the world’s most prestigious consulting firms. spent four years studying the behavior of professionals at the Boston Consulting Group (BCG) Before beginning the study, the researchers surveyed over 1,000 consulting professionals to better understand their work habits. 94% claimed to work more than 50 hours a week, and almost half more than 65 hours a week. This does not include the 20 to 25 hours spent checking email outside of work (at the time of the study, mainly on their BlackBerrys, but we can assume that this phenomenon persists, if not worsens with the use of smartphones). In their experiment at BCG, the researchers imposed a radical method by asking a small group of consultants to take an entire day off in the middle of their working week. During this day, they were forbidden to work and to read their emails or any other form of professional communication. A second group was similarly disconnected, but only after 6 p.m., once a week. This test aimed to measure the effects of total disconnection on the participants’ quality of work and well-being. The experiment was initially greeted with resistance, as most participants were afraid of disappointing their clients or reducing their chances of promotion. Measuring the quality of a consultant’s work can be very difficult, and although methods exist, their performance is often based on the number of hours worked. Presenteeism wins the day. With this in mind, the researchers were able to launch their test and force some of the staff to take a day off in the middle of the week. At the start of the experiment, participants were asked to rate the following statement: “ ” (rated from 1 for “ ” to 7 for “ ”). I feel respected for setting boundaries. strongly disagree strongly agree In the first month, the team responded with an average score of 3.7. After five months, this score rose to 5.2. The study also showed that all participants in this experiment wished to keep a portion of their time totally disconnected. Even more astonishing, 76% of those who didn’t participate in the study also wanted to be included in the experiment after hearing about it. Participants also reported greater job satisfaction, a greater chance of establishing a long-term career with the company, and a better work-life balance. Notably, participants also reported delivering better quality work to their customers. This experiment shows us that, despite the culture established in this group, its usefulness is unfounded. However, without questioning it, it seems to persist and even worsen with the new tools available. Why does constant connectivity persist? The answer may come as a surprise, but it’s pretty clear: it’s because it’s easy. Being constantly connected and reactive is easier than trying to create barriers to distraction. Being reactive is easier than planning long-term tasks. Letting yourself be disturbed is simpler than refusing to be interrupted. In short, the culture of connectivity benefits from our laziness. Cal Newport, author of , calls this phenomenon the “Principle of Least Resistance” and defines it as follows: Deep Work “ In a business setting, without clear feedback on the impact of various behaviors to the bottom line, we will tend toward behaviors that are easiest in the moment.” The Principle of Least Resistance: Two natural forces drive the Least Resistance Principle: If you can get an immediate response to a problem, work becomes “easier.” The need to plan disappears. We then indulge in a reactivity that takes the weight off our shoulders, to the detriment of the group’s concentration. Personal need: In an environment where constant connectivity is accepted, even encouraged, it’s easier to keep up with the general flow. Instead of developing personal organization skills, it’s easier to react to the next email. The fact that performance is indexed to reactivity encourages the preservation of this behavior. Performance measurement: It’s easier, for example, to forward an email to a whole team in the hope of receiving a constructive opinion than to reflect on the content of the email and make a personal analysis. The result: context-free emails asking only “What do you think?” abound in our inboxes (and distract us from more important tasks). The Least Resistance Principle is the primary source of our addiction to constant connectivity. Basically, being connected all the time is lazy. Instead of trying to structure our time, we prefer to let ourselves be carried along by the current of communication. We end up assessing our worth by the number of emails we read and process per day rather than by the tasks we actually complete. And our managers do the same because they are themselves carried by the Principle of Least Resistance. It’s possible to extricate ourselves from this negative connectivity, but it takes effort to set up rules that are beneficial in the long term. How do we escape constant connectivity? The method below aims to set limits on the amount of time you spend on communication so that you can regain control of your time and concentration: 1. Set strict, non-negotiable limits Start by choosing a time slot reserved for rest, during which all professional communication will be prohibited. For example, disconnect completely after 6 p.m. and during weekends. This first step aims to give you time to recharge your attention daily (using can also help). a closing ritual at the end of the day 2. Communicate transparently Your limits must be clearly communicated to your professional entourage. Talk about it with those around you, whether your superior or your customers. Explain that your work's result will be better if you can recharge your batteries daily. Everyone can understand this (and often, even envy you). 3. Define blocks of full concentration Connectivity is also a problem during the day, and these distractions prevent you from completing the most important tasks. To concentrate fully, define times when all forms of communication are forbidden. If you work in an office and are constantly disturbed, use headphones and explain that you are not to be disturbed when you wear them. The goal here is to reduce the constant distractions so that you can rediscover deep concentration. 4. Compartmentalize your schedule Once you’ve established the basics, organizing your time into specific compartments will be easier. For example, emails (twice a day is sufficient). Likewise, define . define specific times for reading and replying to time slots during which you will accept meetings The rest of the time should be devoted to deep, concentrated work. Inserting scheduled breaks into your day to will help you recharge your batteries. Tip: get some fresh air and take a walk As we saw with the BCG example, constant connectivity persists because it is almost impossible to demonstrate that its opposite is more effective. In a world where the Principle of Least Resistance reigns, alternatives to constant connectivity are often ignored. Challenging this paradigm takes courage. It requires reflection on the true meaning and value of work. If being constantly reactive doesn’t suit you, it’s time to . try another method Also published . here

Disconnect to Reconnect: The Counterproductive Culture of Constant Connectivity

In this article, we’ll learn how to handle blockchain disconnects in the production environment automatically, using Web3JS. The method described below works for Web3JS version 1.0.0-beta.35, but it should be good for the stable 1.2.* versions as well. Problem Description If your team uses Web3JS in production, then you must be aware that there’s no inbuilt reconnect functionality in Web3JS to handle blockchain disconnects or restarts. So, usually, when there is a connection drop, NodeJS service needs to be restarted as well to connect to the blockchain again. Not a very practical approach. Solution Let’s see how we can gracefully handle blockchain disconnects in NodeJS. In the Web3JS library, the object gives us events for Provider — connection established Connect — provider errors Error — provider connection ended. End Upon disconnection, we can utilize the event to reinitiate a new Web3JS connection. Let’s look at an example to understand this: end File connection.js In this file, we’ll handle the connection between NodeJS and blockchain. We will have a method which will return a Web3 active connection object. newBlockchainconnection web3 = ( ); hasProviderEnded = , web3Instance, reconnectInterval = ; { provider = web3.providers.WebsocketProvider(webSocketProvider);  
        hasProviderEnded = ; provider.on( , () => .log( )); provider.on( , (err) => .log(err.message)); provider.on( , (err) => { (hasProviderEnded) ; hasProviderEnded = ; provider.reset(); provider.removeAllListeners( );  
                provider.removeAllListeners( );  
                provider.removeAllListeners( );  
   
                setTimeout( { endCallback(); 
                }, reconnectInterval);  
        }); (web3Instance == ) web3Instance = web3(provider); web3Instance.setProvider(provider); web3Instance;  
} .exports = {  
         newBlockchainConnection  
} const require "web3" let false 10000 async ( ) function newBlockchainConnection webSocketProvider, endCallback // create new provider const new false // connect event fires when the connection established successfully. 'connect' console "connected to blockchain" // error event fires whenever there is an error response from blockchain and this event also has an error object and message property of error gives us the specific reason for the error 'error' console // end event fires whenever the connection end is detected. So Whenever this event fires we will try to reconnect to blockchain 'end' async // handle multiple event calls sent by Web3JS library if return // setting hashProviderEnded to true as sometimes the end event is fired multiple times by the provider true // reset the current provider // removing all the listeners of provider. "connect" "error" "end" => () // emitting the restart event after some time to allow blockchain to complete startup // we are listening to this event in the other file and this callback will initialize a new connection if undefined new else return module File app.js connection = ( ); web3JSConnection; endCallback  = {  
        web3JSConnection = connection.newBlockchainConnection( , customEvent);  
 }); { (web3JSConnection == ) web3JSConnection = connection.newBlockchainConnection( , endCallback); web3JSConnection;  
 } .exports = {  
        getWeb3Connection  
} const require "connection" const const async ( ) function await 'ws://127.0.0.1:8545' async ( ) function getWeb3Connection if undefined await 'ws://127.0.0.1:8545' return module Summary On blockchain disconnection, when the provider triggers the ‘end’ event, we are triggering a callback after a timeout. The event then, in turn, calls the function to create a new blockchain connection. Some points to note: Sometimes Web3JS sends you multiple ‘end’ events for the same connection drop, so we have to check if we have already handled the disconnection event once Setting the new provider in the web3 instance object using ‘setProvider’ instead of creating a new web3 instance Resetting the provider and removing active listeners Reconnect interval must be at least 5 seconds as usually, it takes about 5 seconds for the blockchain to restart. Many technology-first companies like Skeps are developing a revolutionary product using blockchain. Stay tuned till our next write-up on this new-age technology. https://skeps.com/blog/how-we-handle-blockchain-reconnects-in-web3js

How We Handle Blockchain Reconnects In web3js

No, You Don't Need a Highly Specialized Team to Build Your SaaS Application 

As a web developer working across both backend (.NET Core, Django) and frontend (mainly React), having the right tools makes all the difference in my daily workflow. Whether it's managing packages, improving terminal experience, or organizing my work, these tools help keep everything running smoothly. Here are my top 10 must-have Mac tools that I rely on every day. 1. Homebrew Homebrew is a package manager that makes installing software on a Mac super easy. It handles the setup and installation of command-line tools, libraries, and other essential software. For developers, Homebrew is especially useful because it removes the hassle of tracking dependencies or updating software manually. Instead, Homebrew does it all with just a few commands. Using Homebrew saves a lot of time, especially if you often need different tools for various projects. With Homebrew, you can easily install, update, and manage packages. It keeps everything in one place, which makes maintaining your development environment much simpler. 2. Oh My Zsh Oh My Zsh is an open-source, community-driven framework that enhances the Zsh shell, making it more powerful and easier to use. It’s packed with themes, plugins, and handy shortcuts. For anyone who spends a lot of time in the terminal, Oh My Zsh is a fantastic way to speed up your workflow. With plugins that support Git commands, auto-completion, and even syntax highlighting, Oh My Zsh turns the terminal into a much more friendly and efficient place. It’s highly customizable, so you can tweak it to match your preferences, making your terminal experience both visually appealing and productive. 3. Shottr Shottr is a screenshot tool specifically designed for developers and designers. It allows you to quickly capture parts of your screen, annotate, and share them with others. Shottr has tools for blurring out sensitive data and for measuring pixel distances, which is incredibly helpful when dealing with UI designs. This tool is particularly lightweight, meaning it won’t slow down your Mac. It’s designed with speed and simplicity in mind, making it ideal for capturing errors, UI details, or any part of the screen that you might need for documentation or collaboration. 4. VS Code Visual Studio Code (VS Code) is a lightweight but powerful code editor that has become a favorite among developers. With support for almost every programming language and a vast library of extensions, VS Code offers a highly customizable development environment. Whether you're working on frontend or backend code, it has everything you need. VS Code’s debugging tools, integrated terminal, and Git support make it ideal for all stages of development. You can also personalize it with themes, snippets, and extensions to enhance your productivity. It’s free, open-source, and highly efficient for both small and large projects. 5. Podman Podman is a container management tool, similar to Docker, but with some key differences. Podman doesn’t require a daemon, making it easier to run containers without root privileges. It’s perfect for developers working with containerized applications who want a lightweight, flexible solution. With Podman, you can manage and run containers directly from the command line, giving you control over your containerized environments. It’s compatible with Docker commands, so if you’ve used Docker before, the transition is simple. For Mac developers working with cloud-native applications, Podman is a great choice. 6. Termius Termius is a modern SSH client that makes remote access easy and secure. With support for SSH, Mosh, and Telnet, Termius lets you connect to remote servers with ease. The app is cross-platform and synchronizes your connections, keys, and settings across devices, so you can access your servers from any device. Termius also has a clean, user-friendly interface that simplifies remote management. It supports multi-tab sessions, making it easy to work with multiple servers at once. It’s a highly secure and efficient tool for managing remote environments, especially if you regularly connect to different servers. 7. Obsidian Obsidian is a note-taking tool designed for developers and creatives alike. It uses Markdown to create and organize notes, making it easy to write down ideas, keep track of code snippets, or document processes. One of Obsidian's key features is its graph view, which visually links notes to show relationships between ideas. Obsidian is especially helpful for organizing thoughts and tracking knowledge across projects. For developers, it’s great for keeping track of troubleshooting steps, project notes, and to-dos. Obsidian is fully offline, so your data stays private and accessible only to you. 8. Postman Postman is an API testing tool that allows you to create, test, and document APIs efficiently. With Postman, you can set up requests, check responses, and even automate testing processes. It supports multiple authentication methods, making it easy to interact with different APIs and check how they perform. Postman also helps with team collaboration by allowing you to share collections of API calls. This is especially helpful for frontend and backend developers working together, as it keeps everyone on the same page. It’s a straightforward tool that makes API testing and documentation much easier. 9. Amethyst Amethyst is a window manager for Mac that helps organize your workspace by automatically arranging open windows. It supports tiling, floating, and fullscreen layouts, allowing you to customize the way applications are displayed on your screen. Amethyst is especially useful if you work with multiple applications and monitors. With Amethyst, you can stay organized without constantly resizing and moving windows around. It helps maintain a clean and efficient workspace, saving time and reducing clutter on your desktop. For developers juggling multiple windows, it’s an essential tool to keep everything in order. 10. Arc Browser Arc is a browser built specifically for organizing web-based workspaces. It lets you organize tabs into groups, making it easy to keep track of different projects, research, or tasks without getting overwhelmed. Arc also has a unique sidebar layout, which makes it easy to switch between tabs and focus on what matters. Arc’s clean and minimal design is perfect for developers who need a distraction-free browser. It supports extensions, so you can customize it just like other browsers, but its organization features are what set it apart. It’s ideal for keeping your online workspaces tidy and focused. Each of these tools has a unique role in my workflow as a web developer, helping me stay organized, work more efficiently, and keep my Mac environment streamlined. If you’re looking to enhance your setup, these apps are a great place to start. As a web developer working across both backend (.NET Core, Django) and frontend (mainly React), having the right tools makes all the difference in my daily workflow. Whether it's managing packages, improving terminal experience, or organizing my work, these tools help keep everything running smoothly. Here are my top 10 must-have Mac tools that I rely on every day. 1. Homebrew Homebrew is a package manager that makes installing software on a Mac super easy. It handles the setup and installation of command-line tools, libraries, and other essential software. For developers, Homebrew is especially useful because it removes the hassle of tracking dependencies or updating software manually. Instead, Homebrew does it all with just a few commands. Homebrew Using Homebrew saves a lot of time, especially if you often need different tools for various projects. With Homebrew, you can easily install, update, and manage packages. It keeps everything in one place, which makes maintaining your development environment much simpler. 2. Oh My Zsh Oh My Zsh i s an open-source, community-driven framework that enhances the Zsh shell, making it more powerful and easier to use. It’s packed with themes, plugins, and handy shortcuts. For anyone who spends a lot of time in the terminal, Oh My Zsh is a fantastic way to speed up your workflow. Oh My Zsh i With plugins that support Git commands, auto-completion, and even syntax highlighting, Oh My Zsh turns the terminal into a much more friendly and efficient place. It’s highly customizable, so you can tweak it to match your preferences, making your terminal experience both visually appealing and productive. 3. Shottr Shottr is a screenshot tool specifically designed for developers and designers. It allows you to quickly capture parts of your screen, annotate, and share them with others. Shottr has tools for blurring out sensitive data and for measuring pixel distances, which is incredibly helpful when dealing with UI designs. This tool is particularly lightweight, meaning it won’t slow down your Mac. It’s designed with speed and simplicity in mind, making it ideal for capturing errors, UI details, or any part of the screen that you might need for documentation or collaboration. 4. VS Code Visual Studio Code ( VS Code) is a lightweight but powerful code editor that has become a favorite among developers. With support for almost every programming language and a vast library of extensions, VS Code offers a highly customizable development environment. Whether you're working on frontend or backend code, it has everything you need. Visual Studio Code ( VS Code’s debugging tools, integrated terminal, and Git support make it ideal for all stages of development. You can also personalize it with themes, snippets, and extensions to enhance your productivity. It’s free, open-source, and highly efficient for both small and large projects. 5. Podman Podman is a container management tool, similar to Docker, but with some key differences. Podman doesn’t require a daemon, making it easier to run containers without root privileges. It’s perfect for developers working with containerized applications who want a lightweight, flexible solution. With Podman, you can manage and run containers directly from the command line , giving you control over your containerized environments. It’s compatible with Docker commands, so if you’ve used Docker before, the transition is simple. For Mac developers working with cloud-native applications, Podman is a great choice. command line 6. Termius Termius is a modern SSH client that makes remote access easy and secure. With support for SSH , Mosh, and Telnet, Termius lets you connect to remote servers with ease. The app is cross-platform and synchronizes your connections, keys, and settings across devices, so you can access your servers from any device. SSH Termius also has a clean, user-friendly interface that simplifies remote management. It supports multi-tab sessions, making it easy to work with multiple servers at once. It’s a highly secure and efficient tool for managing remote environments, especially if you regularly connect to different servers. 7. Obsidian Obsidian is a note-taking tool designed for developers and creatives alike. It uses Markdown to create and organize notes, making it easy to write down ideas, keep track of code snippets, or document processes. One of Obsidian's key features is its graph view, which visually links notes to show relationships between ideas. Obsidian Obsidian is especially helpful for organizing thoughts and tracking knowledge across projects. For developers, it’s great for keeping track of troubleshooting steps, project notes, and to-dos. Obsidian is fully offline, so your data stays private and accessible only to you. 8. Postman Postman is an API testing tool that allows you to create, test, and document APIs efficiently. With Postman, you can set up requests, check responses, and even automate testing processes. It supports multiple authentication methods, making it easy to interact with different APIs and check how they perform. Postman APIs Postman also helps with team collaboration by allowing you to share collections of API calls. This is especially helpful for frontend and backend developers working together, as it keeps everyone on the same page. It’s a straightforward tool that makes API testing and documentation much easier. 9. Amethyst Amethyst is a window manager for Mac that helps organize your workspace by automatically arranging open windows. It supports tiling, floating, and fullscreen layouts, allowing you to customize the way applications are displayed on your screen. Amethyst is especially useful if you work with multiple applications and monitors. With Amethyst, you can stay organized without constantly resizing and moving windows around. It helps maintain a clean and efficient workspace, saving time and reducing clutter on your desktop. For developers juggling multiple windows, it’s an essential tool to keep everything in order. 10. Arc Browser Arc is a browser built specifically for organizing web-based workspaces. It lets you organize tabs into groups, making it easy to keep track of different projects, research, or tasks without getting overwhelmed. Arc also has a unique sidebar layout, which makes it easy to switch between tabs and focus on what matters. Arc’s clean and minimal design is perfect for developers who need a distraction-free browser. It supports extensions, so you can customize it just like other browsers, but its organization features are what set it apart. It’s ideal for keeping your online workspaces tidy and focused. Each of these tools has a unique role in my workflow as a web developer, helping me stay organized, work more efficiently, and keep my Mac environment streamlined. If you’re looking to enhance your setup, these apps are a great place to start.

Stories, News & Mentions about EVCONNECT

Evconnect’s Stories on HackerNoon