Get the most recent info and news about connectBlue on HackerNoon, where 10k+ technologists publish stories for 4M+ monthly readers.

On May 19, 2014, connectBlue was acquired by Swiss based u-blox.

connectBlue

connectblue

The connectBlue serial port adapter with Bluetooth 1.1 wireless technology was used to demonstrate the transmission of electronic data from patient monitors at a recent conference. Bluetooth wireless technology has experienced delays and sundry growing ...

Bluetooth and Medical Devices: Vital Signs Are Robust

Oh, the magic of hardware Not long ago, I showed you . This is kind of cheating for a number of reasons: how to make the game Snake on JavaScript and Canvas Yes, JavaScript runs in any browser, but you still need a browser to run it. Canvas itself is a bit of a shortcut. It is literally a graphics engine inside JavaScript, and you can directly manipulate Canvas with very straightforward commands and coordinates. While using JavaScript and Canvas was challenging and fun and everything, there is a way to make our game even cooler. Let’s build a hardware-based Snake! The core: Arduino At the core of the system, we’ll have Arduino. It’s a system that helps you build DIY robots, sensors, smart home solutions, and even some slow web servers, should you so desire. Arduino itself is a small board with components soldered onto it: At the center of the board, there’s a chip that you can program in any way you like. To program it, you attach the Arduino to your computer and run special software that puts your code onto the chip. See those black sockets on both sides of the board? That’s where you attach wires to carry electricity. The chip that you programmed can read the values of that electricity and act on them. Using Arduino: a quick example Before I go into Snake, here’s a simple home project you can do with Arduino to make sense of how the system works. On one side, you connect the Arduino to two wires that lead to a humidity sensor. The sensor will output a voltage between 0.1 volt and 5 volts, corresponding to how humid the air is. Let’s say the main wire from the sensor is connected to Socket 1 on the Arduino. On the other side of the Arduino, connect an LED light that can be either on or off. To fire it up, you need to send it 5 volts of current. Let’s say the LED is connected to Socket 2. For the chip, you write some code that has the following meaning: Read the voltage from Socket 1 (the humidity sensor) If that voltage is above 2.5 volts, then do nothing for 30 seconds If that voltage is 2.5 volts or less, send 5 volts to Socket 2 (the LED light), do nothing for 60 seconds, and then stop sending power to Socket 2. Repeat until the heat death of the universe To the Arduino, it’s just a matter of taking a reading, doing some logic, and sending power to someplace on its board. The Arduino is unaware of what is attached to it. The Arduino simply routes electricity. But to me, the user, this is a humidity system that alarms me once the air gets too dry. Currently, my system warns me with a light, but should I choose to, I could attach a buzzer instead. I could even attach an electric humidifier and have it turn on to remediate the dry air. Arduino can work as an alarm system, a timer, a notification system, and more. But for us, it’s going to be a game. Collecting the gear For this project, we’re going to need: You can get the classic Arduino or an Arduino Nano. The mini version comes either pins, sockets, or soldering holes. If you want to avoid soldering, make sure you buy a model with either pins or sockets—like this: An Arduino board. This is a plastic board with metal leads underneath. It allows you to connect wires without soldering. Each column of the breadboard is a single lead. If you want to connect two wires, stick them into the same column. A breadboard. Breadboards are a temporary arrangement. So, should you decide to make this game permanent, you’ll need to solder some components together. But for now, a breadboard will be good enough. This matrix has two parts: an arrangement of LEDs that fire up on demand, and a controller board that communicates which LEDs to light up and when. The matrix will communicate with our Arduino board through five pins, and we’ll use the breadboard to connect the matrix to the Arduino. An LED matrix, 8 * 8. We’ll use this to control the snake. A joystick. This device receives electrical current and makes it weaker by some amount. The more you turn the potentiometer’s handle, the weaker the current becomes. This means that if we know how much current we sent over to the potentiometer, and how much current we got back in return, then we can figure out how much the potentiometer was turned. A 10K rotary potentiometer. Get a bunch of wires off Amazon or AliExpress. Make sure you get some wires with pins, some wires with sockets, and some wires with both pins and sockets. Wires are a dime a dozen, so just get a handful. Some wires. Time for assembly If this is your first Arduino project, let’s go over some basics and safety guidelines first: Arduino operates on tiny currents which won’t harm you even if you come in contact with them. However, once you start using external power supplies (like batteries), then improper wiring can cause damage—both to the Arduino and to people. Practice precaution. Disconnect the Arduino from any sort of power supply before you start assembly. While the Arduino is disconnected and there is no external power (like batteries), there is no current flowing, so nothing bad can happen. We connect the components with wires either directly or through the breadboard. The wires allow the current to flow between the Arduino and other devices. To connect anything through a breadboard, stick two pins into the same column (columns are numbered). Everything connected to a single column is interconnected. For current to flow, it needs a source and a drain. The current kind of flows from the source and into the drain. The drain can be called ‘Ground.’ If you connect a device to the source, but don’t provide the connection to ground, then the current won’t flow and the device won’t work. On some devices, you’ll see pins labeled VCC and GND. VCC is the source. GND is ground. If you connect the source and ground directly (without any devices or components in between), then the current will flow like crazy. This will make your wire heat up and eventually burn. This is called a ‘short circuit.’ Never connect the source and the drain directly! Devices and components can share a common source and drain if there is enough power at the source. The term ‘VCC’ refers to the onboard power supply. Arduino has a 5-volt onboard regulator, which means that your VCC socket on the Arduino may be labeled 5V. It depends on which kind of Arduino you buy. What matters is that, for this project, VCC and 5V are the same. Now with basics out of the way, it’s time to connect your components like so: You’ll notice that: All the red wires are connected to 5V, or source. You can hook them all up to the red row on the breadboard and connect that row to Arduino’s 5V socket. That way, you’ll have a common source for all of your components. All the black wires are connected to ground. Connect all grounds to the blue line on the breadboard and hook up that blue line to Arduino’s ground. Now you have a common ground. If you’re having trouble connecting everything in this way, check out this video: Adding the firmware Now you need to connect your Arduino to your computer via the USB cable that came with the Arduino. The Arduino will start up and probably start blinking with an onboard LED, but nothing beyond that. At this point, it’s time to upload the software that will turn your hardware into a playable game. First, go to Arduino’s website, download the Arduino IDE onto your computer, and launch it. (IDE stands for Integrated Development Environment.) Arduino IDE makes it easy for you to write code and upload it to your Arduino board. Next, copy and paste into your Arduino IDE, and press ‘Upload to Arduino’ (an arrow at the top left corner). The software will compile the code and send it over to the Arduino chip. the code for Snake from this developer’s page I won’t bug you with how the code works for now. We just want to get the firmware into the hardware so we can run our game. By the way, firmware means the kind of software that controls a device’s hardware. Once the firmware sits inside the Arduino, the Arduino will start executing that code. The snake will run. Turn the potentiometer to increase or decrease the snake’s speed. Move the joystick to control how the snake moves. The food will blink. And done! Happy snakin’! If you enjoyed learning about hardware, firmware, and making games, you may be interested in exploring . We offer online education and mentoring to help you build essential tech skills and amp up your career. Practicum

Using Arduino To Build Your Own ‘Snake Game’

Friends, fellow adventurers, lend me your ears (or eyes)! Today, we’ll take a joyride into the world of RxJS to tame the sneaky gremlin known as memory leaks. Fasten your seatbelts as we unveil the mystic arts of keeping our code clean and our spirits high. JavaScript The What: Memory Leaks, The Unseen Culprits Alright, before we dive into our detective toolkit, it’s worth taking a moment to truly understand our adversary. . They might sound like something that sprouts in your garden after a heavy downpour, but trust me, they’re a lot less fun. Memory leaks Think of your application’s memory as a high-end, all-you-can-eat buffet. Your Observables are the patrons, consuming memory instead of the latest chef’s special. Normally, they’d eat their fill (perform their operations) and then leave, making room for the next hungry Observable. All’s well in our digital eatery. But here’s where memory leaks, the sneaky critters, slink in. Imagine a patron who eats, and then sits there. And sits. And sits some more. They’re not eating anymore, but they’re taking up valuable space, preventing new patrons from getting a seat. This squatter is our memory leak. In the world of RxJS, memory leaks happen when Observables linger around in memory, long after they’ve finished their tasks. They’re no longer needed, but they stick around anyway, taking up precious space. But why is this such a big deal? Well, the more memory leaks you have, the less memory is available for the parts of your application that genuinely need it. This can lead to slower processing times, and in severe cases, can even cause your application to crash altogether. Imagine your buffet getting so crowded with non-eating patrons that there’s no room left for new customers, or even for the staff to move. Chaos ensues, orders pile up, the kitchen gets overwhelmed, and eventually, the whole place could grind to a halt. That’s the kind of digital disaster we’re looking to avoid. And armed with the right tools and know-how, it’s a disaster we’re going to sidestep with grace and style. So let’s roll up our sleeves and prepare to banish these sneaky squatters once and for all! The How: Gearing Up Against Memory Leaks Now that we’ve identified the culprit, it’s time to arm ourselves with some techy tools to prevent those notorious memory leaks in RxJS. We’ve got five tried-and-true techniques here, each ready to tackle memory leaks in its unique way. Ready? Let’s dive right in! Async Pipe: The Auto-Handler users, rejoice! If you’re using Angular, you can call in the pipe in your templates to handle subscribing and unsubscribing from Observables. Angular oversees the lifecycle of the async pipe, automatically unsubscribing when the component is destroyed. Here's a glance at how this works: Angular async <div>{{ source$ | async }}</div> In this snippet, Angular is taking the wheel, managing the Observable via the pipe and ensures the Observable isn’t left unattended, preventing any mischief. As you might have already noticed, using it requires one main condition to be met. The observable has to be rendered in the template, but this is not always the case. This brings us to the trusty ‘unsubscribe’. source$ async The Trusty Unsubscribe Unsubscribing from Observables is like finishing a good book: you close it, return it to the shelf, and then move on to the next one. And just like the end of a book, you’ve got to know when to say “that’s a wrap” to your Observables. When you subscribe to an Observable, you get back a Subscription object. And this Subscription object carries an method. You'll typically want to call this method in the lifecycle hook if you're using Angular or in the case of React ( for VueJS and etc.). Here's how you do it: unsubscribe ngOnDestroy componentWillUnmount unmounted class MyComponent implements OnDestroy {

  ...

  private subscription: Subscription;

  constructor() {
    this.subscription = source$.subscribe();
  }

  ngOnDestroy() {
    this.subscription.unsubscribe();
  }
} In this Angular snippet, we tell our Observable to halt in its tracks when we're done with it by calling . It's like giving a gentle nudge, reminding it to let go. But what if you are managing a large number of subscriptions and don’t want to write repetitive code for storing subscriptions and unsubscribing? source$ .unsubscribe() The Multi-tasking Combination of takeUntil and Subject: If you’re juggling multiple subscriptions within a component, operator with a Subject has got your back. The concept here is to create a Subject that emits a value whenever subscriptions are no longer needed, for example when the component is destroyed or some other event has happened. Then, you use on every subscription. This way, you're instructing all your Observables to wrap things up when the component is on its way out. takeUntil takeUntil(this.destroy$) class MyComponent implements OnDestroy {
  private destroy$ = new Subject<void>();

  ...

  constructor() {
    observableOne$.pipe(takeUntil(this.destroy$)).subscribe();
    observableTwo$.pipe(takeUntil(this.destroy$)).subscribe();
    ...
    observableNinetyNine$.pipe(takeUntil(this.destroy$)).subscribe();
  }

  ngOnDestroy() {
    this.destroy$.next();
    this.destroy$.complete();
  }
} The tells , and others to keep on keeping on until sends a signal. Once it does, the game is up. No more precious memory is being taken! takeUntil observableOne$ observableTwo$ destroy$ Important to remember that it doesn’t have to happen only when the component is destroyed Here are two example cases: class MyComponent {
  private stop$ = new Subject<void>();
  ...

  constructor() {
    sourceOne$.pipe(takeUntil(this.stop$)).subscribe();
    sourceTwo$.pipe(takeUntil(this.stop$)).subscribe();
    ...
    sourceNinetyNine$.pipe(takeUntil(this.stop$)).subscribe();
  }

  onStopStreaming() {
    this.stop$.next();
    this.stop$.complete();
  }

} In the first one, is being triggered by event method. stop$ onStopStreaming() class MyComponent {
  private stop$ = new Subject<void>();
  ...

  constructor() {
    sourceOne$.pipe(takeUntil(this.destroy$)).subscribe();
    sourceTwo$.pipe(takeUntil(this.destroy$)).subscribe();
    ...
    
    finalise$.pipe(
      tap(() => this.stop$.next()),
      tap(() => this.stop$.complete())
    ).subscribe().unsubscribe();
  }

} And in the other one, it’s being triggered by another observable called . You can probably think of other use cases where this legendary combo can do the job greatly. finalise$ Auto-Complete Operators: The Effortless Unsubscribers Alright, code aficionados, let’s talk about some real gems from the world of RxJS: the auto-complete operators. These operators are like the unsung heroes of your Observable sequences, providing an effortless way to handle subscriptions and ensure graceful unsubscription. Get ready to let these operators take the wheel while you sit back and relax! I’ll cover each operator briefly and provide links where you can read more so that you don’t get too bored and eventually reach the end of an article. first() : The Early Bird First up, we have the trusty . Just like the eager early bird, it swiftly grabs the first emitted value from the Observable sequence and then gracefully completes, bidding adieu to any lingering subscriptions. It's all about getting a head start! first() elementAt() : The Precise Selection Sometimes, you need to be precise, like when you’re searching for your favorite song in a playlist (still can’t come up with a better example). The operator comes to your rescue by allowing you to select a specific element from an Observable sequence based on its index. Once that desired element is emitted, the sequence is automatically completed. It's like having a direct line to the value you want, ensuring your subscribers get exactly what they're looking for. elementAt() take() : The Limited Edition Next on the list is the versatile . Think of it as a limited edition collector's item. With , you can specify the number of values you want to pluck from the Observable sequence. Once it reaches that magic number, it gracefully exits the stage, leaving the spotlight on the chosen few. take() take() takeWhile() : The Conditional Watcher Last but not least, we have the observant . This operator acts as a watchful sentinel, keeping an eye on the values emitted by the Observable sequence. As long as a specific condition holds true, it dutifully passes the values along. But the moment the condition evaluates to false, it exits the stage with a graceful bow. takeWhile() These auto-complete operators are like your trusty sidekicks, taking care of the subscription lifecycle and ensuring you don’t have to worry about memory leaks. So go ahead, embrace the simplicity, and let these operators do the heavy lifting for you! Rock ’n’ Roll with Hot Observables But what if you have multiple subscriptions to one Observable? Here comes our next super start. Picture this: you’re at a concert and the band is jamming. Regardless of when you or other fans join in, the band doesn’t start the song over, right? The melody (data) keeps flowing! That’s the beauty of hot observables. They’re the cool rock stars of the RxJS world, belting out data, whether anyone is there to groove to it (subscribe) or not. The charm of hot observables is their easy-going nature. Their data production doesn’t care for the formalities of subscription; it’s like they’re in their own world, performing data sequences independently. This means you’re not stuck initiating a new data sequence for each new fan (subscriber). Sounds like a pretty sweet gig for memory and processing power, eh? Now, in the RxJS band, you’ve got some built-in functions like , , , , etc., that are born hot observables. But guess what? You can also turn a cold observable into a hot one using the or other similar operators ( , , , etc). Check this out: fromEvent() interval() of() timer() share() shareReplay() connect() connectable() // cold observable, chilling alone
const cold$ = new Observable((observer) => {
  observer.next(Math.random());
});

// hot observable, ready to rock
const hot$ = cold$.pipe(share());

// Fans (subscribers) join the party
const subscription1 = hot$.subscribe(val => console.log(`Fan 1: ${val}`));
const subscription2 = hot$.subscribe(val => console.log(`Fan 2: ${val}`));

setTimeout(() => {
  // A late fan gets the same experience
  const subscription3 = hot$.subscribe(val => console.log(`Fashionably late fan 3: ${val}`));
}, 1000); See what we did there? We transformed a lone, cold observable into a hot one with the operator. Now, no matter when the fans (subscribers) decide to join the party, they're jamming to the same data, reducing the need for multiple encores (executions). share() There you go, code rockstars! You’ve got the power of hot observables at your fingertips. Ready to rock ’n’ roll with memory efficiency? Let’s hit it! Let’s view a bit more boring example that is very common in daily life: getUserData() {...} // makes api request and returns user data as Observable
getUserAccounts() {...} // makes api request and returns user accounts as Observable
getUserTransactions() {...} // makes api request and returns user transactions as Observable
const user$ = getUserData();

// option 1: using cold observable 
const coldUser$ = user$; // API will be called 2 times
const userAccounts$ = coldUser$.pipe(concatMap((user)=>getUserAccounts(user)));
const userTransactions$ = coldUser$.pipe(concatMap((user)=>getUserTransactions(user)));

// option 2: using hot observable case
const hotUser$ = user$.pipe(share()); // API will be called once and result will be shared
const userAccounts$ = hotUser$.pipe(concatMap((user)=>getUserAccounts(user)));
const userTransactions$ = hotUser$.pipe(concatMap((user)=>getUserTransactions(user))); <div>{{ userAccounts$ | async }}</div>
<div>{{ userTransactions$ | async }}</div> Both and utilize a response from a common observable. The advantage of using the observable (as in option 2) is that the API for fetching user data will be called only once since there will be a single subscription, and the response will be shared. userAccounts$ userTransactions$ hotUser$ The Wrap: You’re Now a ‘Leak Detective’ And that’s a wrap, folks! Armed with , , , and many others, you're now a certified RxJS memory leak detective. You're ready to charge into the battlefield, slaying memory leaks left and right. async unsubscribe takeUntil Just remember, the secret to keeping your code clean is understanding and vigilance. With these trusty tools and strategies, you’re on your way to crafting efficient, leak-free code. Good luck, fellow code warriors. May your code be bug-free and your coffee strong! Also published here. Lead image by Lokajit Tikayatray

Mastering RxJS Memory Leaks: The Leak Detective Handbook

How to Build a Web3 NFT Cross-Breeding Dapp with React, Solidity, and CometChat

“Whoever controls the DNS, controls the universe” (image credit: OpenAI Dalle2) spice The following article will provide a very brief overview of what DNS actually is, and what makes it “authoritative”. Then, I will discuss why you may choose to disregard its authority in some cases in order to have a better browsing experience and gain a bunch of superpowers using a service our team has built over the last 2 years. Strap yourself in. What is DNS First things first: what is DNS? DNS (Domain Name System) is a distributed “phone book” that maps (domain) names to IP addresses. When you enter hackernoon.com into your browser, it will query the router on your network for the IP address of hackernoon.com. Your home router doesn’t perform any DNS resolution and forwards the request upstream to whatever DNS server is configured there. This could be your ISP or a 3rd party resolver like Cloudflare 1.1.1.1 or Google 8.8.8.8. These resolvers are typically recursive in nature, meaning they reach out to the root DNS servers for the .com zone, and perform a recursive lookup against the authoritative DNS servers for the DNS zone (hackernoon), and then you finally get the IP(s) that hackernoon.com resolves to. So your DNS query takes the following route (simplified view): Your Device → Router → DNS Provider → Root Name Server → Authoritative Server → IP Address Saul Goodman explains this best. This process is fairly slow and can take ~1s, so typically the response is cached by the DNS provider for some period of time so the next lookup can be served from a cache. Your browser will also cache the response for the duration of the TTL associated with a particular DNS record, so as not to initiate a DNS query every single time. The responses that the authoritative DNS server emits are typically static. This means that any user, anywhere, asking any DNS server “where is hackernoon.com” will get the same response: yegor@Work-Desktop:~$ dig +short hackernoon.com 172.67.69.96 104.26.11.89 104.26.10.89 There are some notable exceptions to this when it comes to CDNs, which will geo-code your source IP, and return variable results based on your location. A user in the UK will see different IPs than a user in the US. This is done for performance reasons, so people in different countries connect to the nearby CDN location in order to reduce latency. That being said, you’re still bound by what the authoritative DNS server returns (or doesn’t). The above flow is true for pretty much every single thing that you do online that communicates with a remote server. Every web resource you download,  every API call you make, and every Git commit you do resolves a domain to an IP address that the authoritative DNS server returned. What if you could disregard what the authoritative server tells you? What advantages (superpowers) does that have? Let’s dive in. What is Control D Control D, as you probably guessed, is a DNS service. It can do all the things your standard DNS provider can (resolve  domains), but it can also do a lot more. Control D is a user-configurable DNS service that offers transparent proxies deployed on top of an anycast network, with exit locations in over 69 countries. Sure, that all sounds impressive, but what does it ACTUALLY do? When you get started with Control D, you will get a set of DNS resolvers that are unique to your account and can enforce your unique configuration. Think of it as your personal authoritative DNS server, for the entire Internet. You can customize your configuration via a simple web interface, as there are no required apps to install to use the service.  Control D supports multiple DNS protocols: - least secure, but most widely supported Legacy IPv4/IPv6 - most secure, supported by modern OSes DNS-Over-HTTPS (DoH) - most secure, supported by modern OSes DNS-Over-TLS (DoT) The first protocol offers the best compatibility and can be used on any Internet connectable device. Legacy DNS is not encrypted, so it can be easily intercepted and manipulated by your ISP, or network administrator. The latter two offer you the best privacy and security, as your DNS queries are encrypted with TLS and cannot be intercepted or manipulated. Think of it as: Legacy = HTTP DoH/DoT = HTTPS What’s the difference between DoH and DoT and which one is better? Honestly, just stick with DoH, as it operates on TCP port 443 and is indistinguishable from normal HTTPS traffic. DoT operates on a special port (853) and is easily detectable (and therefore easily blocked). The advantages of DoT (less overhead and therefore faster resolution time) are debatable, and we have not seen them in practice. Mind you, on some platforms like Android, you have no choice but to use DoT, as DoH is not supported ( ). but will be soon Once you configure one of the DNS resolvers on your device (router, computer, browser, phone) your DNS queries will be steered to the Control D network. By default, if no settings are changed, Control D will behave like a standard DNS resolver, no different than Cloudflare, Google, or your local ISP. Once you start fiddling with the knobs, you can do of neat things, by selectively disregarding authoritative DNS records and substituting your own. all kinds Block a category of sites (ads, or porn for example) Block malicious domains non-malicious domains that point to malicious IPs and Block a specific service (Facebook, or TikTok) Block a specific TLD, FQDN, subdomain, or a wildcard entry (i.e. server-*.domain.com) Spoof a service, TLD, FQDN, subdomain, or all DNS queries to a specific IP address of your choice (think a wildcard-supporting hosts file) Redirect a specific service through a proxy location (BBC iPlayer through London, for example) Redirect a specific TLD, FQDN, subdomain, or wildcard entry through a proxy location (All .ca domains get proxied through Toronto) Redirect resolved DNS queries through a specific proxy location (there are over 100 cities to choose from) all Override blocks enforced by category filters, or services Schedule any of the above behavior to kick in at a certain time of day A whole bunch more TL;DR: Control D allows you to selectively disregard the authoritative DNS records associated with any domain you attempt to resolve (regardless of it actually existing in public DNS), and replace the answers with anything you want. This can prevent the domain from loading by spoofing  it to an IP of your choice (like 127.0.0.1), or to one of over 100 supported by Control D. Then, Control D will transparently proxy SNI (and some non-SNI) enabled traffic through servers in that location/country. exit locations You can also block, spoof, and redirect ALL of your DNS queries by using the catchall "Default Rule". Bad Use Cases You wouldn’t use a hammer to perform dental surgery (hopefully) - every tool has its use case. The same applies here, so before we jump into why you use a service like Control D, let's spend a moment talking about why you . should shouldn't Life Critical Anonymity If you live in a country where freedom of speech is non-existent, or you are a whistleblower, dissident or political activist, you should not use Control D to stay safe online. Despite Control D encrypting your DNS queries, even if you are using the proxy capabilities to spoof your location, the Server Name Indication (SNI) TLS extension is still transmitted in plaintext. This means that on adversarial networks where this information is captured and filtered, Control D will not provide you any security benefits. It will not be able to unblock restricted sites, and your browsing history could still be captured by the network administrator. If this is your particular use case, you are much better off using a (shameless self-plug as Windscribe is our sister company). Do keep in mind that a VPN is not a magical security solution either, despite what you may have heard from your favorite YouTuber while they react to videos of people describing the taste of meat to vegetarians. trusted, no-logging VPN Their scripted “opinions” are worth less than the Zimbabwean dollar.  A VPN is just tools that should be in your toolbelt if you care about these things.  I could rant all day about this, but let’s move on. one of the many BitTorrent Control D will not affect the BitTorrent protocol. Since this is a P2P protocol, which does not rely on DNS, all your torrent activity will be in the clear. Control D offers an optional filter that will block all common torrent indexes and trackers, which will make the use of the BitTorrent protocol difficult on the network where Control D is deployed (and this Filter enabled), but it will not 100% eliminate all torrent activity. If you wish to apply a layer of privacy to your torrent activities, you should use a VPN. Gaming (Improvements) Many people use VPNs for gaming in order to "improve ping" or mask their IP from trolls. The efficacy of this is , but Control D is unlikely to help here. In fact, there is a good chance that if you redirect all your traffic to our proxies, it will break some games entirely. debatable We recommend disabling Control D functionality if you experience problems playing your favorite games. You can do this from the section of the control panel; simply find your game and create a rule. Services BYPASS Actual Use Cases So now that we got that out of the way, what CAN you use Control D for? The following list is not exhaustive but should give you an idea of the flexibility you can achieve. Block Ads, Trackers, and Malware (and many other things) Yes, you can use a browser extension like uBlock that will do a really good job blocking things in your browser (until anyway, when we all eat a Google turd sandwich). January of 2023 However, this will just block ads in your favorite desktop browser. All tracking (and ad delivery) that happens outside of the browser (OS, installed programs, mobile applications, and browsers) will get through. If you set up Control D inside the operating system, or on your router, all DNS queries that any application makes (including the browser) will query your personal resolver, and all your rules apply. This means you can eliminate 99% of all ads and trackers (as well as 14 other categories)  from even loading on your devices. This effectively creates a network/system-wide ad block, which is highly effective. With this in mind, you can block many other categories, including: Malware distributing, typosquatting, and phishing domains (if you accidentally click a shady link) Adult content (handy on networks with kids) Social networks (stop wasting time looking at your "feed") IoT telemetry (prevent your fridge from talking to servers in China) Gambling, Drugs, Dating sites (keep your vices in check) A whole bunch more Help with Dev Efforts You’re probably familiar with the host’s file, which allows you to define domain names that may not exist in public DNS. You can also use it to override the DNS responses that are in public DNS to point to your local dev machine or a remote dev server. With Control D you can have a remote hosts file. This has several advantages: You can enforce the same host’s file on all your dev/test devices, including a mobile (or your smart toaster) Control D supports wildcards entries, so you can redirect all subdomains with a single rule Simulate regional access to your project from over 100 city-level locations Eliminate Your Pi-Hole Pi-Hole is a great tool to control your network, deploy custom blocklists, and have visibility on what is being resolved, but there are downsides: Pi-Hole only works on your home network – Control  D works on all networks, including cellular. You have to manage blocklists yourself – Our bespoke filters are built on top of community-maintained blocklists, with tens of thousands of false positives removed, based on feedback from 45M Windscribe users. We did all the work for you! Lack of advanced blocking – Pi-Hole only blocks domain names. Control D malware filter also blocks domains that resolve to malicious IPs from threat intelligence feeds. Lack of scheduling or flexibility – With Control D, your rules don't have to be static. They can change day to day, and be different on different devices. You have to run it yourself – Control D is deployed on top of a global anycast network, is available everywhere, including cellular networks, and supports Secure DNS protocols out of the box. (Selectively) Spoof Your Location Unlike a VPN, which sends all your activity to a single server in a chosen country, you have a lot more, well, when you use Control D. Since it operates at the DNS layer, you can create all kinds of rules in your configuration to do all kinds of things. control Here is a silly example of 7 different websites seeing you in 7 different places, all at once: You can instruct Control D to resolve different FQDNs through proxies in different countries, with as little as 3 clicks. When your browser asks to resolve a domain that has a rule, Control D will return a proxy IP instead of the true IP of the destination (disregarding the authoritative answer). It will read the SNI, and forward the end-to-end encrypted request to the site you wanted to load. From here, we can get fancier. Instead of creating individual rules, you can create a folder of rules, and assign an action (block, redirect, or bypass) to it. Any domain you add to this folder will inherit and apply the chosen folder rule. Don't want to make your own rules? That's where the Services section comes in. We've created rules for over 200 most common services online, and this list is always growing based on . user requests With a single toggle switch, you can apply a chosen rule to a video streaming service, an audio service, a store, a tool, a social network, or a game.  Each service can be redirected through a unique location (or blocked entirely), so you can appear to be in 69 countries, all at once. Lastly, you can redirect all your activity through the closest , if you don't care about the geolocation of your IP. This will have the best performance and supports IPv6 end-to-end. Control D Primary Location Optionally, you can choose a specific exit location (city), which will double hop your traffic from the closest Control D Primary Location to a Windscribe VPN server in the chosen country. All of this is without having to install a VPN app. You can use all 3 behaviors in parallel to create some very unique browsing profiles. The rule engine works as follows: Custom rules take precedence over everything Service rules are second in line, and are checked if there are no custom rules that match the DNS query Filters (which block things) are 3rd in-line and will match a domain if there is no overriding custom rule or Service rule Last in line is the Default Rule, which will, like the name suggests, match queries that aren't affected by any of the above Parental/Productivity/Impulse Controls The internet is full of distractions and outright harmful content. You may choose to block certain types of content at certain times of day (or all the time) so you can get stuff done, or prevent your kids from wasting time when they should be doing their homework. Control D gives you the tools to block large categories of distractions (social networks and games) so you can concentrate on your school or work. You can also use the same tools to block harmful content like porn, drugs, and malware on your network if you have kids. You can make these rules permanent, or time-based using the Scheduler. Here are some examples: Block social networks and games every Monday to Friday, and allow playtime on the weekends during certain hours Block porn, Reddit, and TikTok Monday to Friday 9 am to 5 pm so you can remain gainfully employed and boost your productivity British TV Fridays: Every Friday your Netflix and Disney+ shows British content Shopping Tuesday Mornings: All popular shopping sites are blocked every day except for 1hr on Tuesday morning. Then you can decide if you REALLY needed those $800 custom sock puppets you found at 3 am after a few drinks, and thought were super cool. Unique Device Configurations You're not limited to a single set of rules. Each account allows you to have up to 10 unique browsing profiles (configurations), and you can then create up to 10 devices and enforce your configurations using unique per-device DNS resolvers. Your personal laptop and phone can have one profile,  your partner's iPad could use another, and your kids' phones can use the rest. Each physical device can be configured to access or block a unique set of filters, services, and custom rules. Conclusion As you can see, there's a you can achieve with Control D, and this article really only scratches the surface. I recommend you (no payment details required!) and play around with it - I think you will be pleasantly surprised. It's time to take back control of your Internet experience. lot get yourself a trial account PS. The service is very much in active development, so if you have an idea or a suggestion, don’t hesitate to send us any and all feedback. We release new stuff weekly.

What Is DNS and Why You Should Control It

How to Accept Crypto Payments in a Classic Commerce App

In this article, I will be showing you how to create a Dapp that allows us to store data on the Arweave network, using bundlr on testnet. Before going forward, let’s see what are we going to build today. https://www.loom.com/share/808aff5aa5d84ead93c106cfb96ff05f?t=70 Here is the deployed link if you want to try it out: https://bundlr-arweave.netlify.app/ Tech Stack and Libraries I’ve Used: Nextjs Chakra UI RainbowKit Wagmi Bundlr Client Well, Well, Let’s Go Through What Is Arweave and Bundlr First (From the Doc). If you enjoy videos like me, here is a video for you: https://www.youtube.com/watch?v=DQbwiiXMtMo Arweave Arweave makes information permanence sustainable. Arweave is a new type of storage that backs data with sustainable and perpetual endowments, allowing users and developers to truly store data forever — for the very first time. Bundlr Bundlr makes web3 data storage on Arweave accessible by making it as fast, easy, and reliable as traditional data storage. Arweave is the only truly decentralized, permanent data storage solution. Bundlr increases the number of transactions conducted on Arweave by 4,000% without sacrificing security or usability and is around ~3,000x faster at uploading data. Bundlr currently accounts for over 90% of data uploaded to Arweave. It enables infinite scalability and enables instant and guaranteed transaction finality. It is a multichain solution and is compatible with leading blockchains including Ethereum, Solana, Avalanche, Polygon, and many more. Steps We Have to Follow to Upload to Arweave using Bundlr Connect wallet Initialize the Bundlr client Add funds ($BNDLR tokens) Upload the files we will be bulding this app on polygon mumbai testnet. Bundlr has a devnet which allows you to use devnet/testnet cryptocurrency networks to pay for storage. The devnet node behaves exactly as a mainnet node - other than data is never moved to Arweave and will be cleared from Bundlr after a week. Note: Let's Get Building Keep the completed code open on the side for a better understanding . Github 1. Setting up the project Setup a Nextjs project with tailwind CSS and Chakra UIYou can use package to get done with setup quickly or just clone this Also, install these two dependencies create-web3-frontend . project repo yarn add @bundlr-network/client bignumber.js 2. Connect wallet As we are using Rainbow kit this step is very easy in index.tsx const Home: NextPage = () => {
  const { data } = useAccount();
  if (!data) {
    return (
      <div className='justify-center items-center h-screen flex '>
        <VStack gap={8}>
          <Text className='text-4xl font-bold'>
            Connect your wallet first
          </Text>
          <ConnectButton />
        </VStack>
      </div>
    )
  }

  if (activeChain && activeChain.id !== chainId.polygonMumbai) {
    return (
      <div className='justify-center items-center h-screen flex '>
        <VStack gap={8}>
          <Text className='text-4xl font-bold'>
            Opps, wrong network!! Switch to Polygon Mumbai Testnet
          </Text>
          <ConnectButton />
        </VStack>
      </div>
    )
  }
} And with these 5–6 lines of code, we are done with connecting the wallet 🎉 We have also added a condition to check if a user is on the Mumbai test, as we will be using polygon Mumbai testnet for this article. In while configuring Rainbow kit we have configures it for using polygon Mumbai testnet _app.jsx const { chains, provider } = configureChains(
  [chain.polygonMumbai],
  [
    jsonRpcProvider({ rpc: () => ({ http: process.env.NEXT_PUBLIC_ALCHEMY_RPC_URL }) }),
    publicProvider(),
  ]
); So, Rainbow kit will also take care of changing the network for us, this is how this warning will look like 3. Initializing the Bundlr Let’s create a context for bundlr, so we can maintain all bundlr related logic form there. Create . Inside this file let's create the context now, you can see the completed version of the file bundlr.context.tsx here import { WebBundlr } from '@bundlr-network/client';
import { useToast } from '@chakra-ui/react';
import BigNumber from 'bignumber.js';
import { providers, utils } from 'ethers';
import React, { createContext, useContext, useEffect, useState } from 'react'

const BundlrContext = createContext<IBundlrHook>({
    initialiseBundlr: async () => { },
    fundWallet: (_: number) => { },
    balance: '',
    uploadFile: async (_file) => { },
    bundlrInstance: null
});

const BundlrContextProvider = ({ children }: any): JSX.Element => {
    const toast = useToast()
    const [bundlrInstance, setBundlrInstance] = useState<WebBundlr>();
    const [balance, setBalance] = useState<string>('');

    useEffect(() => {
        if (bundlrInstance) {
            fetchBalance();
        }
    }, [bundlrInstance])

    const initialiseBundlr = async () => {
        const provider = new providers.Web3Provider(window.ethereum as any);
        await provider._ready();
        const bundlr = new WebBundlr(
            "https://devnet.bundlr.network",
            "matic",
            provider,
            {
                providerUrl:
                    process.env.NEXT_PUBLIC_ALCHEMY_RPC_URL,
            }
        );
        await bundlr.ready();
        setBundlrInstance(bundlr);
    }

    async function fundWallet(amount: number) {
        try {
            if (bundlrInstance) {
                if (!amount) return
                const amountParsed = parseInput(amount)
                if (amountParsed) {
                    toast({
                        title: "Adding funds please wait",
                        status: "loading"
                    })
                    let response = await bundlrInstance.fund(amountParsed)
                    console.log('Wallet funded: ', response)
                    toast({
                        title: "Funds added",
                        status: "success"
                    })
                }
                fetchBalance()
            }
        } catch (error) {
            console.log("error", error);
            toast({
                title: error.message || "Something went wrong!",
                status: "error"
            })
        }
    }

    function parseInput(input: number) {
        const conv = new BigNumber(input).multipliedBy(bundlrInstance!.currencyConfig.base[1])
        if (conv.isLessThan(1)) {
            console.log('error: value too small')
            toast({
                title: "Error: value too small",
                status: "error"
            })
            return
        } else {
            return conv
        }
    }

    async function fetchBalance() {
        if (bundlrInstance) {
            const bal = await bundlrInstance.getLoadedBalance();
            console.log("bal: ", utils.formatEther(bal.toString()));
            setBalance(utils.formatEther(bal.toString()));
        }
    }

    async function uploadFile(file) {
        try {
            let tx = await bundlrInstance.uploader.upload(file, [{ name: "Content-Type", value: "image/png" }])
            return tx;
        } catch (error) {
            toast({
                title: error.message || "Something went wrong!",
                status: "error"
            })
        }
    }

    return (
        <BundlrContext.Provider value={{ initialiseBundlr, fundWallet, balance, uploadFile, bundlrInstance }}>
            {children}
        </BundlrContext.Provider>
    )
}

export default BundlrContextProvider;

export const useBundler = () => {
    return useContext(BundlrContext);
} For initializing the Bundlr we will be using the method from the code above initialiseBundlr and the code is also pretty straightforward const bundlr = new WebBundlr(
            "https://devnet.bundlr.network",
            "matic",
            provider,
            {
                providerUrl:
                    process.env.NEXT_PUBLIC_ALCHEMY_RPC_URL,
            }
        );
        await bundlr.ready();
        setBundlrInstance(bundlr); We are creating an instance of the Bundlr client and storing it in a state variable. Read more about For using Bundlr with testnet . bundlr client read here In order to use the devnet, you need to use as the node and set the provider url to a correct testnet/devnet RPC endpoint for the given chain. https://devnet.bundlr.network Our, RPC URL will look something like this, as we will be using polygon testnet NEXT_PUBLIC_ALCHEMY_RPC_URL=https://polygon-mumbai.g.alchemy.com/v2/{{alchemy_project_id}} Read, about all the supported . currencies/ networks by bundlr here 4. Add funds ($BNDLR tokens) 💸 We already have data about our in the bundlr context, and we also have a method which we will be using to add the funds. Adding funds is also pretty straightforward, just use the method on the bundlrInstance and pass the amount you want to fund the wallet with balance fundWallet fund let response = await bundlrInstance.fund(amountParsed) In , make these changes index.tsx const Home: NextPage = () => {
    const { initialiseBundlr, bundlrInstance, balance } = useBundler();
    ...

    // at last
    if (!balance || Number(balance) <= 0) {
        return (
          <div className='justify-center items-center h-screen flex '>
            <VStack gap={8}>
              <ConnectButton />
              <Text className='text-4xl font-bold'>
                Opps, out of funds!, let's add some
              </Text>
              <FundWallet />
            </VStack>
          </div>
        )
      }
} Now let’s create the component. Create <FundWallet /> components/FundWallet.tsx import React from 'react'
import { Button, NumberDecrementStepper, NumberIncrementStepper, NumberInput, NumberInputField, NumberInputStepper, Text, VStack } from '@chakra-ui/react'
import { useBundler } from '@/state/bundlr.context';

const FundWallet = () => {
    const { fundWallet, balance } = useBundler();
    const [value, setValue] = React.useState('0.02')

    return (
        <div className='mt-12'>
            <VStack gap={6}>
                <Text fontSize={'xl'}>
                    Your current balace is: {balance || 0} $BNDLR
                </Text>
                <NumberInput className='mx-auto' step={0.01} defaultValue={value}
                    onChange={(valueString) => setValue(valueString)}
                >
                    <NumberInputField />
                    <NumberInputStepper >
                        <NumberIncrementStepper />
                        <NumberDecrementStepper />
                    </NumberInputStepper>
                </NumberInput>

                <Button onClick={() => fundWallet(+value)}>💸 Add Fund</Button>
            </VStack>
        </div>
    )
}

export default FundWallet 5. Upload images 📷 Now, as we’ve already added the funds, now we can upload the images (or any other files), to the Arweave network. In , add the following code at the end of the file index.tsx return (
    <div className='justify-center items-center h-screen flex'>
      <Stack direction={['column', 'row']} justifyContent={'space-around'} width={'full'} alignItems={'center'}>
        <VStack gap={8}>
          <ConnectButton />
          <FundWallet />
        </VStack>
        <VStack gap={8}>
          <Text fontSize={'4xl'}>
            Select Image To Upload
          </Text>
          <UploadImage />
        </VStack>
      </Stack>
    </div>
  ); Now, let’s create the component <UploadImage /> import React from 'react'
import { Box, Button, Text } from '@chakra-ui/react';
import { useBundler } from '@/state/bundlr.context';
import { useRef, useState } from 'react';

const UploadImage = () => {
    const { uploadFile } = useBundler();
    const [URI, setURI] = useState('')
    const [file, setFile] = useState<Buffer>()
    const [image, setImage] = useState('')
    const hiddenFileInput = useRef(null);

    function onFileChange(e: any) {
        const file = e.target.files[0]
        if (file) {
            const image = URL.createObjectURL(file)
            setImage(image)
            let reader = new FileReader()
            reader.onload = function () {
                if (reader.result) {
                    setFile(Buffer.from(reader.result as any))
                }
            }
            reader.readAsArrayBuffer(file)
        }
    }

    const handleClick = event => {
        hiddenFileInput.current.click();
    };

    const handleUpload = async () => {
        const res = await uploadFile(file);
        setURI(`http://arweave.net/${res.data.id}`)
    }

    return (
        <div className='flex flex-col mt-20 justify-center items-center w-full'>
            <Button onClick={handleClick} className='mb-4'>
                {image ? 'Change Selection' : 'Select Image'}
            </Button>
            <input
                accept="image/png, image/gif, image/jpeg"
                type="file"
                ref={hiddenFileInput}
                onChange={onFileChange}
                style={{ display: 'none' }}
            />

            {
                image &&
                <Box
                    display='flex'
                    alignItems='center'
                    justifyContent='center'
                    width='100%'
                    py={40}
                    bgImage={`url('${image}')`}
                    bgPosition='center'
                    bgRepeat='no-repeat'
                    mb={2}
                >
                    <button className='bg-gray-200 rounded px-8 py-2 text-black hover:bg-gray-100' onClick={handleUpload}>Upload File</button>
                </Box>
            }

            {
                URI && <Text className='mt-4'>
                    <Text fontSize='xl'> Uploaded File:</Text> <a href={URI} target="_blank">{URI}</a>
                </Text>
            }
        </div>
    )
}

export default UploadImage And, with this in place, we can now upload the files to the Arweave network 🚀 Further Improvement: Right now we are only uploading images, we can add support for other formats as well (video, audio, anything) Store URLs of uploaded images with wallet address in Supabase and show the list of files previously uploaded by users when they connect their wallet Completed code: GitHub Also published . here

Permanent File Storage for Web3 Apps With Arweave, Bundlr, Next.js, RainbowKit, and Wagmi

Over the past few years, IoT has become one of the most important technologies of the 21st century. The Internet of things (IoT) describes physical objects that connect and exchange data with other systems over the Internet. A thing, on the internet of things, can be a person with a heart monitor implant, a farm animal with a biochip transponder, an automobile that has built-in sensors to alert the driver when tire pressure is low or any other natural or man-made object that can be able to transfer data over a network (even something basic in your kitchen). The concept of the "Internet of things" and the term itself, first appeared in a speech by Peter T. Lewis, in September 1985. According to Lewis, "The Internet of Things, is the integration of people, processes and technology with connectable devices and sensors to enable remote monitoring, status, manipulation and evaluation of trends of such devices." Now that we can connect everyday objects to the internet via embedded devices, seamless communication is possible between people, processes, and things. By means of low-cost computing, the cloud, big data, analytics, and mobile technologies, physical things can share and collect data with minimal human intervention. IoT can also make use of artificial intelligence and machine learning to aid in making data collecting processes easier and more dynamic, considering that now cars can communicate with the buildings, that connect and communicate with human personal assistants (like Alexa) which can also communicate with your kitchen stuff and back communicate with other sensors around the city. Going forwards, sensors  could be used to monitor events or changes within structural buildings, bridges and other infrastructure. This brings benefits with it, such as cost saving, saved time, quality-of-life workflow changes and paperless workflow. A home automation business can utilize IoT to monitor and manipulate mechanical and electrical systems in a building. On a broader scale, smart cities can help citizens reduce waste and energy consumption. But security is the biggest concern in adopting Internet of things technology, with concerns that rapid development is happening without appropriate consideration of the profound security challenges involved and the regulatory changes that might be necessary to protect personal data and privacy. IoT wearables enable people to better understand their own health and allow physicians to remotely monitor patients. This technology also enables companies to track the health and safety of their employees, which is especially useful for workers employed in hazardous conditions. The precious thing here, is that now we can collect this large amount of data (non-personal), bring some Data Science to the conversation and predict healthcare concerns in a population or a trend in terms of risk to human health. In this hyperconnected world, digital systems can record, monitor, and adjust each interaction between connected things. The physical world meets the digital world, and they cooperate. Thank you for reading another article here! I hope you enjoyed! There's even more good things I've prepared for you! Do you want to read some book notes and recommendations? Discover more here! Do you want to have amazing weekly content curation? Discover more here! Follow me on - - LinkedIn Twitter Instagram Originally published . here

The IoT At  A Glance

My name is Dmitriy Dudarev. I develop electronics, and I love to create different portable devices. I also love music. A long time ago, in April 2020 or so, when the whole world was shaken by the terrible quarantine, I decided to learn to play guitar. I borrowed an acoustic guitar from a friend of mine and started to study the instrument by lessons on YouTube and tablatures. It was hard. Maybe, I was doing something wrong, maybe, I didn’t try hard enough, or maybe, fine motor skills prevented my predecessors from reproduction. All in all, I couldn’t produce anything but sounds of rattling strings. The constant mistuning of the strings strengthened my resentment. And my neighbors got no pleasure from listening to my uneven “Nothing Else Matters” thousands of times. But, in the middle of all these sufferings, I haven’t forgotten the main rule of a techie. If something exists, you can insert a microcontroller there. Or, at least make a portable electronic modification. Electronic guitar? Hum, an interesting idea, I thought. But it would be even better if I could learn to play this guitar myself. On the same day, the acoustic guitar was returned to my friend, and I started to develop the idea. As I’m an innate engineer; I made a list of requirements for the device. What do I want from my guitar? I want something that looks like a guitar as much as possible, that is, six strings and at least 12 frets on the fingerboard. 1) I want it to be compact and portable. So that I can take the device wherever I go, not having to book a truck for transportation. 2) The device should be able to connect to anything without any tricks — from iOS to Windows. Ok, ok, let’s be realistic– to all the popular OSs. 3) Work using a battery. 4) The connection should be wireless (However, there will be a USB-port for recharging and connectable using a wire too) 5) The most important point — learning to play the guitar should be easy, without the necessity for long training on wrist ligament adaptation. So, how do I make it come true? It occurred to me to equip the guitar and the strings with LEDs. For example, you upload tablatures in your guitar, and it shows you itself where to put your fingers. That is, there is nothing like looking at the screen, then at the guitar, then again at the screen, and again at the guitar. I don’t need all this stuff. You look only at the guitar. And you play the same guitar. That’s all. That’s what my idea was! 6) I’d like to have the support of different playing techniques: hummer on, pull off, slide, vibrato. 7) No retards. Speaking scientifically, the delay of midi-commands shouldn’t exceed 10ms. 8) Everything should be assembled “from shit and sticks” — easily available materials without complicated technical processes and expensive electronics. 9) As a result, we should get a compact instrument that I can play like a guitar free from the shortcomings of an analog one, equipped with a visual learning system; it sounds realistic. Of course, we need to write an app for mobile platforms, and you can choose a tablature for training with LEDs, choose an instrument (acoustic, classical, electric guitar with different filter presets, ukulele, etc.), and make sounds. Existing analogs But do I need to invent a bike? Because for each great idea, there is always a Chinese person who has already done it “in hardware” and made it better than you were going to initially. I’m looking it up on Google. The first digital guitar turned out to have been created back in 1981, but it hasn’t become popular because of its weak functionality. More modern variants have also been found, for sure. For example, with an iPad instead of strings, or another, in the shape of a mollusk: However, fulfilling all my wishes–first of all, compactness and “press-on-LEDs” training mode — there is no such a thing. Besides, such midi-guitars are still purposed for a more skilled audience. Moreover, they are expensive. So let’s go! First prototype In order to check the viability of a concept, I need to determine the element base at first. Let’s take the STM32F042 controller. It has everything I need, and it costs less than a buck. Except for the wireless connection, but we will return to it later. Let’s go ahead — strings on the soundboard. For the first concept, I decided to print plastic reeds, attach them to potentiometers with springs and measure deviation angles. That’s how 3D-model looks like: And that’s in reality: It feels pleasant. It should work. For frets on the fingerboard, I’ve ordered on AliExpress such tenso-resistors. Unlike different buttons, they don’t click. It is also possible to define the strength of pressure, which means that I can play complicated techniques like slide or vibrato. I also need ADC to read the info from sensors and transmit it to the controller. While I was waiting for sensors from China, I made a PCB layout: Before ordering board printing, I decided to wait for piezoresistors. And, as it turned out, it wasn’t in vain. Of 80 sensors, only a few were working, and even they had different parameters. To put it mildly, it doesn’t look the way it was declared. But what was I expecting when I bought the components on AliExpress? And then it dawned upon me. I can apply another detection method — capacity measuring like in touch sensors. That’s much cheaper and more accessible. And if I design the mechanicals correctly, I’ll be able to define the effort. Well, I’m removing everything that was done before. Second prototype Well, let’s do away with the piezoresistors! For sensor elements, this time, I took small copper cylinders sawed from a wire. For capacity measuring, I could find an affordable 12-channel universal capacitometer. It measures capacity in picofarad units, which should be enough for a scheme of strength measuring, which I’m going to implement in the following modifications. Additionally, just in case, I’ve hung a seat for a button or something of the kind on each element of the fingerboard, and made cuts in the board so that I could not only touch the cylinder but also press on it inside. I’ll try to experiment with different playing techniques. Having solved the question of connecting a lot of chips of capacitometer to the controller, I’m starting the board wiring. This time I could order the board and even wait till it is ready. After the components, copper cylinders, and potentiometers are soldered, I understood that construction with plastic strings is too complicated. So for a while, I decided to hang the same sensor cylinders on the soundboard, but a bit longer. Two little wires in the lower part — I’ve connected a plate with cylinders to the board. It is a temporary solution. The hard part is done. The next step is to make it play. Software The program part was created as follows: Downloading the virtual synthesizer, which can work with midi-device and produce guitar sounds. 1. Writing firmware for controller, which will poll the sensors and transmit the data via USB to the PC. 2. On the part of the PC, I wrote the program which will receive these data, generate midi-packages of them, and send them to the virtual synthesizer from point 1. 3. Now every step in detail: I found quite a lot of virtual synthesizers for Windows with midi support. I tried Ableton live, RealGuitar, FL studio, and Kontakt. I stopped on RealGuitar because it is easy and designed especially for guitar. It can even imitate the imperfection of human play — fingers sliding along the strings, randomized parameter of note production. To connect my app to the virtual synthesizer, I emulated a virtual midi-port which is connected to the input of the virtual synthesizer RealGuitar via an emulator of midi-cable — such as a multi-level emulation. In the program interface, I’ve made graphic imaging of the measured capacity level for each sensor. This way, it will be easier to tune the sound. Besides, for the future, I added the elements for control of LEDs, vibromotor (I don’t know yet, why, but it will be in the guitar, too), visualization of accelerometer work, and battery charge level. To make the hits on guitar strings cause correct notes, I need to map all the 72 sensors on the fingerboard to the respective note. I found that, of 72 elements, on 12 frets, there are only 37 unique notes. They are located by a certain structure so that instead of building a large table, I could make up a simple equation, which generates a number of respective notes by the number of sensors. Checking the work It looks like everything is ready for the first test. I was too lazy to saw the rods and solder all the 12 frets, so I was happy with eight. The moment of truth: IT’S ALIVE! The proof of concept is confirmed. My happiness had no bounds! But I mustn’t relax. The next stage is adding LEDs, accelerometer, vibromotor, battery, wireless connection, body, and the possibility of work without drivers or midi emulation programs on all the popular platforms. LEDs According to my plan, the guitar should prompt the user where he should put his fingers by lighting a LED at that point. In total, we need 84 LEDs. It is easy. I took 14 8-bit shift registers and connected them in a daisy chain. STM transmits the data to the first register, the first one — to the second one, the second one — to the third one, etc. And all this — through DMA, without participation of controller core. Accelerometer The simplest accelerometer — LIS3D — will enable the guitar to define its descending angle. In the future, I’ll use it for sound filter applications while I play, depending on the guitar position. Wireless connection For wireless data transmission, I decided to put ESP32. It supports different Bluetooth and WI-FI protocols; there will be something to experiment with (at that time, I hadn’t known yet that in my case, there is only one correct way of connection). Body One of the key requirements of the guitar is its portability. So it should be foldable, which means that I must allocate electronic components of the soundboard and the fingerboard into two boards and connect them using a ribbon cable. Power will be supplied when the body opens when the magnet of the fingerboard approaches the Hall sensor on the soundboard. Prototype revision Well, it is time to dress the device in a nice outfit. I did a lot of experiments with tactile elements of the fingerboard and diffusers for LEDs. I’d like the whole surface of the element to shine evenly, but at the same time, there should be a possibility of touch detection and pushing the buttons. There are some of these experiments here: I also consulted with a friend of mine, an expert in industrial design. We invented the construction of guitar folding, after which he projected and printed the body prototype. I’m creating the final variant of the board and assemble the guitar: Looks almost cool. But the device is still connected to the PC via a chain of emulators which emulate other emulators. Turning the guitar into a midi-device In the new version, first of all, I’d like the guitar to be defined as a midi-device without unnecessary programs when connected via USB. I found that it was not so difficult to do it. All the specifications can be found on the official website usb.org. But all the algorithms performed on the part of python-app had to be rewritten in C to the controller. I was surprised that it started to work on all the devices: Windows 10, MacOS, Debian 9, Android (via USB-adapter). You can only insert the cable, and a midi-device named Sensy appears in the system and is read by all the synthesizers. I couldn’t test it on the iPhone yet because I’ve got no adapter. But it should work the same way. Wireless interface Now it is time to get rid of the wires. The right solution hasn’t come to me because I was too lazy to properly look it up on Google. But, as a result, I used the BLE MIDI protocol, which is supported by all the new OSs and works without any drivers, just like via USB MIDI. However, probably, the solution will fail on older OSs because there is no support for BLE MIDI. But all the tests with available devices were successful. Rewritten app functions, that is, translation of sensor data into midi-data, occupied the whole controller memory accurately. Only 168 bytes left unoccupied. Evidently, the silicon gods were gracious to me, which meant that I was moving in the right direction. Sure, it can be optimized, but I’ll leave it for the next version. Though, it is better not to waste my time and just take a bigger controller. The difference in money is five cents. We’ll see, anyway, I’ll need a space for new features — for instance, processing playing techniques. First of all, I’d like to implement a slide. It is when you start playing a note with a certain pressed fret and slide with your hand along the fingerboard jumping from fret to fret. Now we can check how it works wirelessly: When all the LEDs are on, you can use the guitar if you get lost in a dark cavern. Prototype shortcomings Currently, the construction has the following disadvantages: The strength of pressure cannot be measured anywhere on the sensors. It brings about three problems: 1) There are constant touches of neighboring strings both on the soundboard, and on the fingerboard. It makes the play very difficult. All the notes you play sound with the same loudness. Most of the experiment subjects don’t notice it, but I’d like to get sound that is closer to a real guitar It is impossible to use hammer on, pull off, and vibrato techniques The LEDs are of the same color. It limits visualization when you play by tablatures. I’d like to have the ability to indicate different playing techniques with different colors. 2) The shape of the body doesn’t suit left-handed persons. From a software point of view, I’ve already implemented string inversion by accelerometer. But mechanical petal necessary for holding the guitar with your hand when you play turns only to be comfortable for right-handed persons. 3) Absence of footrest. Now when you play sitting, the lowest string almost touches your leg, and it is uncomfortable. 4) The flexion joint of the guitar requires comprehension and revision. Probably, it is not reliable and stable enough. 5) It is time to pass on to the development of the next version. Moving to a controller of STM32F07 series, it already has 128 KB of flash — it should be enough for any functions. Using ESP32 in the final version of the guitar would be too much, so I went to look for something more conventional. I made my choice in favor of NRF52 by accessibility criteria, presence of documentation, and adequacy of the website. Certainly, three main updates will be implemented: - Now the LEDs are RGB, - On each fingerboard sensor, there will be strength measuring (bar buttons are not necessary anymore), - The strings on the soundboard will be mobile. Currently, the board of the soundboard looks like this (I’ve left ESP footprint just in case): I’m already completely sure that all the intended functions will be implemented, so made a decision about further development. We will open a startup and publish it on Kickstarter:) The project is called and is now under active development. We are based in St.-Petersburg; the team consists of three people: I’m responsible for the technical part, my partner Ildar — for marketing, finance, legal issues and Roman - for the musical and content part. Sensy At the moment, the electronics, software and case have been completely redone. The story will be continued soon in the next article! Those who are fond of following the project updates, please, leave your email in the form on the website and subscribe to social media. I really hope to get feedback from you with your comments and suggestions! Thank you for your attention! Funny episode from the development process I was sitting and debugging NRF52, trying to output the data via UART. No results. I checked the code, soldering, even re-soldered the chip — nothing works! And then randomly, I restarted the board in an unusual way –letter N came to the terminal in ascii. It corresponds to number 0x4E, which I haven’t sent. I restarted again — letter O has come. It is strange. Perhaps, the problem is in the quartz resonator, and the baud rate has failed? I changed the frequency in the terminal, restarting the board — again, N came. With every new restart, a new letter came, which eventually made a repeated phrase — “NON GENUINE DEVICE FOUND.” What does this NRF venture do? I’ve cleared the firmware. How on Earth can it remember after the restart what was sent last time? It looked like a kind of seance. Perhaps, I’m the very NON GENUINE DEVICE? When I looked up on Google, I found out that manufacturers of FTDI chips, which are installed in USB-UART dongles, found a way of fighting with Chinese counterfeits. Windows driver checks chip originality and on the go replaces the input data with this phrase if it is counterfeit. Evidently, my dongle turned out to be a counterfeit, and replacing another has solved this problem. I thank the counterfeits again.

How I Created a Digital Guitar and Turned It Into a Business

(OSM) is maybe the most extensive open data project for geo-data. It has rich information on points of interest (POIs), such as apartments, shops, or offices, globally. You can truly call it a data treasure. Also, the big players, like Apple, Amazon, and Facebook, realized that and built heavily upon this global community project (Visual by: ) OpenStreetMap Jennings Anderson State of the Map To also enable smaller data science teams to benefit from this resource,  we created an ETL pipeline to directly download the raw OSM data in the file format and store the transformed objects in a database. Leveraging indexing, you can then easily query those objects with radius or polygon queries. .pbf Uber’s H3 In the remaining parts of this article, I will show you how we approached the transformation of the raw data using the power of streams in . All of the code snippets are open-source, just as everything else at Kuwala. You can find it on . Node.js our GitHub Streams in are an elegant way to process big files while not using a lot of memory. The reason is that you don’t need to load the entire file into  the memory to perform transformations on or work with the data, but it packs them in batches. That way, even on files with millions of rows, the memory consumption stays consistently low. Of course, you need to write the transformed data directly to a database or file system or perform requests based on the data in the batch and not store everything in intermediate in-memory objects. Node.js We can already use streams when downloading the OSM files since the file size may be several gigabytes big depending on the region you want to download. You first need to create a write stream that writes the data to a specified file path. You then pipe it to the data stream of the request-response object and continue when the stream is finished. { downloadUrl = pickFile(); (!downloadUrl) { ( );
    } filePath = ; fse.ensureDir(filePath.split(filePath.split( ).pop())[ ]); writer = fs.createWriteStream(filePath); response = axios.get(downloadUrl, { : , : });

    response.data.pipe(str).pipe(writer); ( {
        writer.on( , () => resolve(filePath));
        writer.on( , reject);
    });
} async ( ) function downloadFile const await if throw new Error 'No file selected' const `tmp/osmFiles ` ${downloadUrl.split(baseUrl)[ ]} 1 await '/' 0 const const await method 'GET' responseType 'stream' return new Promise ( ) => resolve, reject 'finish' 'error' Now that we downloaded the file, let’s parse it into handleable objects and write them to a database. First, we create a read stream that reads the file. For parsing the OSM protocol buffer into JSON objects, we use the npm package. With the pipe command, you can connect a writable stream to a readable stream. There is a particular class, the Transform stream, which implements both the Readable and Writable interface. Using that, we can break the entire filtering and transformation down into semantic streams and pipe them together. osm-pbf-parser After parsing the format to JSON, we want to create more concise objects based on the OSM tags, which is just a list of key-value pairs. The objects in the OSM file are ordered by type. First nodes, then ways, and lastly relations. Which makes a lot of sense since ways consist of nodes and relations consist of ways. So with our first transformer, we store all the nodes in a temporary database. We use here, a fast key-value store developed by Google. Secondly, we filter all objects that do not contain relevant tags for classifying them as a POI, e.g., nodes that only exist to represent a point in a building footprint. Thirdly, we create building footprints for ways and relations, so the outline of a building, for example. In the OSM objects, only the references to the nodes that form the building footprint are stored. We retrieve the relevant nodes from the LevelDB and generate the geometries in GeoJSON format. Next, we get the centroid based on these geometries, which we then transform to H3 indexes with another Transformer. pbf LevelDB { ( (resolve, reject) => { levelDbPath = ; { db = level(levelDbPath); pbfParserStream = parseOSM(); stream = fs.createReadStream(file);

            stream
                .pipe(pbfParserStream) .pipe(levelDbStream(db)) .pipe(tagFilterStream) .pipe(buildingFootprintStream(db)) .pipe(locationStream) .pipe(h3Stream) .pipe(tagStream) .pipe(modelStream) .pipe(mongodbStream(bar)) .on( , () => { Poi.insertMany(pois).catch(reject);

                    addedObjects += pois.length; db.close();
                    rimraf.sync(levelDbPath);
                    addUnmatchedTags(); resolve();
                })
                .on( , (error) => {
                    rimraf.sync(levelDbPath); reject(error);
                });
        } (error) {
            rimraf.sync(levelDbPath); reject(error);
        }
    });
} async ( ) function parseFile file return new Promise async const 'tmp/levelDb' try const await const const // Parse pbf format to JSON objects // Store every node in temporary database to generate building footprints // Filter irrelevant items // Construct building footprints for ways and relations // Get lat lng pair for center based on point or building footprint // Convert location to h3 index // Convert relevant tags into categories and properties // Create model objects // Save objects to mongodb 'finish' async await await // Add unmatched category tags to category list under "misc" 'error' // Delete temporary database catch // Delete temporary database is a spatial index developed by Uber, which is a great way to connect several geospatial data sources because you can quickly traverse from one resolution to another. We aggregate tags relevant to POI properties such as categories, addresses, or contact details in our next pipe. Lastly, the transformed objects are wrapped in Mongoose objects to validate the schema and so that we can write them to the database in the last pipe. H3 Having passed these transformations, we now have handy objects that you could either load into your data warehouse or query over an API with, for example, radius and geometry queries. At , we want to unify geospatial data and make them easily integratable and connectable. To have a significant impact, we are entirely open-source and believe in the power of the community. If you work with data, make sure to star us on and our Slack community. Kuwala GitHub join Also published on: https://medium.com/kuwala-io/using-node-streams-to-transform-the-largest-poi-database-37218f28c996

How to Use Node Streams to Transform the Largest POI Database

Most of us are using Google Photos to store our valuable memories and screenshots of documents we frequently need like identification cards. This was a win-win for us as well as Google. We could use free storage and a good application interface to access our photos at the expense of our privacy, and Google could improve its Artificial Intelligence algorithms with the feed from our photos at the expense of a free storage offer. However, it all changed in June, when Google stopped its free service. Now it has become a loss for us, loss of privacy, loss of money and most importantly, loss of confidence in what else Google might change in future. That was the time my friend our draft of work for building an open-source Google Photos alternative with React Native, but it was not when we started the project. published https://github.com/functionland/photos How did it start? It was two years ago when cryptocurrencies and blockchain were the news page highlight, yet again. Everyone was excited about the potential of blockchain for decentralizing traditional central banks, however, the news didn’t have many headlines about the work that was being done to decentralize the whole web. At that time my friend, an AI geek, and I, a full-stack developer,  discussed this and started to search on the internet. We came across several promising projects aimed to decentralize the web and finally, after analysing many of them, IPFS and IPLD, both open-source, caught our eyes. They seemed promising to us, since they had a mature structure and a big community of open-source developers contributing to them. So we thought, this was great, why were people not using them instead of central storage servers? And the answer was not hard. As we spoke to our developer and non-developer friends, it became apparent that even many developers were not aware of these projects and many non-developers did not have the technical knowledge to set them up on their computers, even though it was just a few lines of command. Besides, there were not many applications that could connect to them or their UX were not as appealing as those developed by big-tech. We thought a framework that combines easy-to-use backend APIs, easy enough for an average front-end developer, and a pre-setup hardware, plug and play for a non-technical person, can fill this gap and bring decentralized web to everyone’s home. I need to mention that NAS, such as synology, although powerful,  is not what we wanted to achieve. We wanted a full application node, in other words a decentralized server, not just a file disk. Some Background: We joined the IPFS and IPLD community to learn more about it. After a few months we came to realize its huge potential to deliver on the promise of the decentralized web. If you don’t know what IPFS is, it stands for “Interplanetary File System”. As the name suggests it is a file system, designed to decentralize file and data storage with p2p connection, a replacement for http protocol. It uses libp2p toolset, implementing the same protocol that empowers Ethereum network p2p connection. IPFS also uses IPLD, Interplanetary Linked Data. If you are familiar with JSON-LD, it has the same grounds but is much more powerful, because it can link any data types with each other. In simple words, IPFS hashes the data content and gives this hash to the user. Hash is unique per file content, meaning two files with the exact same content have the exact same hash, so it has de-duplication built-in, no “disk clean-up” needed! Anyone who has the file hash, can find where the file is located using a decentralized hash table and connect directly to the host using “libp2p” and fetch the content. You can even create a cluster for keeping a set of nodes synchronized with each other, so that if one goes down another one can serve the file. You can define which files your node should serve (and keep a local copy) and which ones it should not. You do not need to have a static IP or domain name to serve a file to others, which is an advantage compared to cloud services or NAS. How did it go? We started to use IPFS to store files in a decentralized way and IPLD as the base of our database engine. There was one shortcoming though. IPFS data can be accessed by anyone who has the hash to it. That is not so private, right? Although IPFS has a private mode, at that time (and currently), it does not work well over the internet and is more suited for private networks. But there was another technology to cover this hole, called proxy re-encryption. This means you encrypt your data locally using your private key. When you want to share the file with someone, you use proxy re-encryption to re-encrypt the file using the other person's public key, and announce the address of the new file on the internet. They retrieve the encrypted file, and can decrypt it using their own private key! So you can share an encrypted file without sharing your private key. We had all the pieces figured out, and to put them together, we needed simple hardware with all the requirements pre-installed. Then it becomes a plug-and-play node that can be used as an application server. It uses an open-source package allowing anyone to use it freely and contribute It does not require any technical setup It can be accessed over the internet using libp2p without any domain or static IP. It can serve both files and data (database) It encrypts and protects user’s data It is modular, meaning hardware modules(towers) can be added as needed. For example, a hardware module(tower) for mining crypto, and one for additional storage can be added to the base. The software provides easy-to-use APIs for front-end developers to build applications without having to deal with backend code Here is what we came up with in terms of hardware design and called it “box” (initially “Black Box”, but we changed it so that it won’t be confused with an airplane appliance!) : Although “box” is the hardware designed to give a pre-setup option to non-tech-savvy people, anyone can install box’s server software ( a package of IPFS+IPLD+proxy re-encryption back end) on any computer, even a raspberry pi, and turn it into a “box”. Availability of data was also important. What if the user’s box is destroyed as a result of a flood? We thought a user should be able to own more than one “box” or share it with a family member or friend (being allowed to only access their part of files) and synchronize the content to have more than one copy of their files, in case a flood destroyed one of the boxes! It should also be connectable to the filecoin network, a decentralized file storage network built on top of IPFS to securely store files in a network of decentralized nodes at a reduced cost, to give more safety to more cautious people. We then thought of finding a way to enable front-end developers to jump aboard quickly and easily. Speaking of quick and easy in “programming languages” terms, Javascript was the apparent winner. A powerful and widely used language! So we thought of Node.js as a good choice for the backend to provide APIs that can be used by front-end developers in any application, including react and react native applications. It was around the time Google announced it was going to charge us for Photos, and we thought it could be a good contribution as well as a showcase for this open source platform. And to show how easy it was to develop on this backend and how useful it would be for end users, we started developing an open-source react native Google Photos alternative using react native. It is still in active development and initial release will be in July, but we were so excited to share it as soon as we reached a working version. You can see the github here: https://github.com/functionland/photos Where are we now? The Photos application is the first front-end app, as an open-source replacement for Google Photos, which can connect to any backend (AWS, GCloud, Azure, other hosts, box, IPFS network called filecoin) to store and fetch photos. We made it using react-native and typescript, and minimized using react states in it to minimize re-renders and make it as smooth as, and smoother than, Google Photos. “box-server” is the open-source back-end that is used to store the data, synchronize data between boxes and re-encrypt and share the files with others. It provides a javascript library to be imported in the react native application, and enables the application to directly connect to the user's box using libp2p. “Graph” is the open-source library that allows front-end developers to interface with the “box”, using a familiar package. The code for all these are packaged in the “box” monorepo: https://github.com/functionland/box We plan to release the MVP working demo of “box” and Photos app, in July. By that time users should be able to try it out to store their photos and access them with the same experience they gain now from Google Photos, and get a taste of decentralized web and really owning their data. It also allows front-end developers to see the APIs and start developing their own applications if they find it useful. If you want to read more about the idea of box, take a look at our website: https://fx.land The Potential? “box” idea can be a step forward to bring decentralized web to everyone’s home, and at least partially, replaces traditional big-tech services with their corresponding decentralized version. Web3.0 frees the internet from the control of a few corporations and gives the control of data back to users. “box” can turn into your “Loyal Agent”. If Netflix wants to suggest movies to you, they do not get your information. You store your information on your own box and install the movie suggestion application provided by the community (it can even be Netflix itself). Netflix connects to your box and sends a list of movies it has. “box” processes Netflix data, cross checking it with your data and suggests the movies to you. No data goes out of your box to Netflix, but it still allows you to get personalized movie suggestions or to share whatever you want with whoever you want in an encrypted and safe way. But if it is FREE, how is it sustained? Developers who jump aboard need to eat too! Like current web experience, there would exist many free applications, and paid ones too. Users can choose to install a mining module(tower) on their box, so that it mines crypto and keeps it for them. Then,if the developer of an application sets a price for the application they develop, box pays the price with the mined currency, instead of paying Google, or any corporation, with our private data and attention for ads. Moreover, it allows the developers to customize applications for their own box and share this customized(and probably feature-rich) version of the application with friends and family. In this path, we would love to have the developers’ community support. You can check out our GitHub repository to let us know your comments. Eagerly looking forward to hearing your comments! Please do not hesitate to leave constructive feedback or bash the whole idea to the ground! Only in common wisdom shall we thrive, no one soul knows all, most definitely not the noobs who started this :) -- Love and peace, Functionland

How We're Building an Open-Source Google Photos Alternative with React Native

This is the second part of the series where we create a service to interact with MySQL server in Rails using MySQL2 gem. You can read the first part . here Requirements [x] Service to connect with external MySQL server [ ] Perform basic query: select, insert and update [ ] Prepared statement [ ] Perform transaction [ ] Perform join query In the previous blog, we created a service and also added a method to perform operations. Today we will be adding additional methods to help us perform insert and update operations to MySQL server using MySQL2 gem. select In this blog We will be learning the following in this blog: Perform insert query Perform update query Perform Insert Query Insert query is used to create a new record in the database. Code def insert(attributes)
  query = format_insert_query(attributes)

  perform_mysql_operation mysql_connect.query(query)

    puts end
end

private

def format_insert_query(attributes)
  raise attributes.empty?

  columns = attributes.keys.join( )

  values = attributes.values.collect! { |value| }.join( ) end do 'Record inserted!' 'Attributes cannot be empty' if ',' "'#{value}'" ',' "INSERT INTO #{table} (#{columns}) VALUES (#{values})" Explanation is taking the hash parameter from the method. The following is happening inside the method: format_insert_query attributes insert Get column names by formatting key part of attributes param Get values to insert by formatting value part of attributes param Construct and return an insert query Following is happening inside the method: insert Call to get a query that can directly be used for the insert operation format_insert_query Insert to database Practically: will be received as the parameter, which will be sent to to get formatted query {first_name: 'John', last_name: 'Doe'} attributes format_insert_query Inside , will have value key part of the hash format_insert_query columns "first_name,last_name"; attributes will have the value part of the hash. values "'John','Doe'"; attributes Lastly, if was it will return table users "INSERT INTO users (first_name,last_name) VALUES ('John','Doe')" Now the method will send the query to the server and the new record will be inserted into the database. insert Perform Update Query An update query is used to update existing records in the database. Code def update(id, attributes)
  query = format_update_query(id, attributes)

  perform_mysql_operation mysql_connect.query(query)

    puts end
end

private

def format_update_query(id, attributes)
  raise attributes.empty?

  formatted_attributes = attributes.map { |key, value| }.join( ) end do 'Record Updated!' 'Attributes cannot be empty' if "#{key}='#{value}'" ',' "UPDATE #{table} SET #{formatted_attributes} WHERE #{primary_column}=#{id}" Explanation There is only one change in to . It’s taking as parameters. The parameter lets us know which existing record we want to update in the database. It is getting formatted query and updating in a database, the concept is the same as insert with only change in the query. update insert id id has a slight difference to that of ; it is converting differently. Let’s see that with a practical example below. format_update_query format_insert_query attributes If we are providing and same as insert query, will return id=1 attributes format_update_query "UPDATE users SET first_name='John',last_name='Doe' WHERE id=1" Now the method will send the query to the server and update the record with in the database. update id=1 Final Code If you have been following the tutorial from , you will have the following in your service file: Part 1 MySqlServer Database = table
        @primary_column = primary_column
      end

def fetch_all
        perform_mysql_operation result = mysql_connect.query( )

          puts result.entries
        end
      end

def fetch_one(id)
        perform_mysql_operation result = mysql_connect.query( )

          puts result.entries
        end
      end

def insert(attributes)
        query = format_insert_query(attributes)

        perform_mysql_operation mysql_connect.query(query)

          puts end
      end

def update(id, attributes)
        query = format_update_query(id, attributes)

        perform_mysql_operation mysql_connect.query(query)

          puts end
      end

private

      def connect_to_db
        host = ENV[ ]
        database = ENV[ ]
        username = ENV[ ]
        password = ENV[ ]

        Mysql2::Client.new(username: username, : password, : database, : host)
      end

def perform_mysql_operation
        raise ArgumentError, unless block_given?

        begin
          @mysql_connect = connect_to_db rescue StandardError => e
          raise e
        ensure
          mysql_connect&.close
        end
      end

def format_insert_query(attributes)
        raise attributes.empty?

        columns = attributes.keys.join( )

        values = attributes.values.collect! { |value| }.join( ) end

def format_update_query(id, attributes)
        raise attributes.empty?

        formatted_attributes = attributes.map { |key, value| }.join( ) end
    end
  end
end require 'mysql2' module module : , : , : ( , )
        @ class Connect attr_reader mysql_connect table primary_column def initialize table primary_column table do "SELECT * from #{table}" do "SELECT * from #{table} WHERE #{primary_column}=#{id}" do 'Record inserted!' do 'Record Updated!' 'MYSQL_SERVER_IP' 'MYSQL_DB_NAME' 'MYSQL_USERNAME' 'MYSQL_PASSWORD' password database host 'No block was given' yield 'Attributes cannot be empty' if ',' "'#{value}'" ',' "INSERT INTO #{table} (#{columns}) VALUES (#{values})" 'Attributes cannot be empty' if "#{key}='#{value}'" ',' "UPDATE #{table} SET #{formatted_attributes} WHERE #{primary_column}=#{id}" After this, our service should be able to perform basic queries in the external MySQL server using MySQL2 gem. Next week we will be learning how we can perform queries with the prepared statement which helps us to avoid SQL injection issues. Cover Image by on Image Credits: Kelvin Yang Unsplash This post was first published on DevPostbyTruemark .

How to Connect With External MySQL Servers (Part 2: Insert & Update Operations)

Rails has made our lives easier. If we are talking in terms of querying the database, the active record has got us covered. But what if we had to communicate with an external database? Recently in one of the projects that I worked on, I had to perform insert, update, select, and other different queries to the external MariaDB server and I didn’t know what to do. I figured out that it would be easy if I created a service that can work like ORM to perform the query I wanted. Skills required to follow the tutorial Intermediate in: Rails SQL Requirements Service to connect with external MySQL server Perform basic query: select, insert, and update Prepared statement Perform transaction Perform join query In this blog Our requirement list is very long, so we will split this blog into various parts. We will be looking at the following requirements in this one: Service to connect with external MySQL server Perform basic query: select Service to connect with external MySQL server We will be using gem for our purpose. Let’s first create a service to connect with an external MySQL server. mysql2 Create a file inside and add the following to it. connect.rb lib/my_sql_server/database Code MySqlServer Database = ENV[ ]
        username = ENV[ ]
        password = ENV[ ]
        database = ENV[ ]

        Mysql2::Client.new(username: username, : password, : database, : host)
      end

      def perform_mysql_operation
        raise ArgumentError, unless block_given?

        begin
          @mysql_connect = connect_to_db rescue StandardError => e
          raise e
        ensure
          mysql_connect&.close
        end
      end
    end
  end
end require 'mysql2' module module : class Connect attr_reader mysql_connect private def connect_to_db host 'MYSQL_SERVER_IP' 'MYSQL_USERNAME' 'MYSQL_PASSWORD' 'MYSQL_DB_NAME' password database host 'No block was given' yield Explanation Here, we are creating a service with a private method that connects to our external MySQL database. We are using the following from : connect_to_db application.yml host: IP address of external MySQL server username: User of the database password: Database password database: Database name In , for security reasons; we are making sure that connection to the external database is closed once all the query operation is completed. perform_mysql_operation Perform basic query: select Select query Select query lets us fetch row/s from our database. Select all Code = table
  end

  def fetch_all
    perform_mysql_operation result = mysql_connect.query( )

      result.entries
    end
  end
end : , : ( )
    @ class Connect attr_reader mysql_connect table def initialize table table do "SELECT * from #{table}" Explanation We are initializing variable, this is the name of the table that we want to perform queries on. We are adding it to the initializer so we can use the service with any table we want, it lets our code to be dynamic and flexible. table method will execute the query to fetch all records from the external MySQL server. Inside the method, we are using which accepts a block of our code, catch errors, and ensure the connection is closed after the query is completed. fetch_all perform_mysql_operation We are saving the result to which will return an instance of mysql2 class. And to get actual rows, we are using method. result entries Select one Code = table
    @primary_column = primary_column
  end

  def fetch_one(id)
    perform_mysql_operation result = mysql_connect.query( )

      result.entries
    end
  end
end : , : , : ( , )
    @ class Connect attr_reader mysql_connect table primary_column def initialize table primary_column table do "SELECT * from #{table} WHERE #{primary_column}=#{id}" Explanation We have added to our initializer; this is the column name of the primary key in the table. Although normally we use as the primary key, that won’t always be the case. The primary key can be of any name when working on a real project, so we are handling that with . primary_column id primary_column is fetching a single record from the table. We are passing as the param, which should be the id of a record we want to fetch. We are using condition so as to only fetch a record with that particular id. fetch_one id WHERE Final Code MySqlServer Database = table
        @primary_column = primary_column
      end

def fetch_all
        perform_mysql_operation result = mysql_connect.query( )

          result.entries
        end
      end

def fetch_one(id)
        perform_mysql_operation result = mysql_connect.query( )

          result.entries
        end
      end

private

      def connect_to_db
        host = ENV[ ]
        username = ENV[ ]
        password = ENV[ ]
        database = ENV[ ]

        Mysql2::Client.new(username: username, : password, : database, : host)
      end

def perform_mysql_operation
        raise ArgumentError, unless block_given?

        begin
          @mysql_connect = connect_to_db rescue StandardError => e
          raise e
        ensure
          mysql_connect&.close
        end
      end
    end
  end
end require 'mysql2' module module : , : , : ( , )
        @ class Connect attr_reader mysql_connect table primary_column def initialize table primary_column table do "SELECT * from #{table}" do "SELECT * from #{table} WHERE #{primary_column}=#{id}" 'MYSQL_SERVER_IP' 'MYSQL_USERNAME' 'MYSQL_PASSWORD' 'MYSQL_DB_NAME' password database host 'No block was given' yield We created a service that connects to an external MySQL server and performs basic select operations in this part. We will learn how to perform basic insert and update operations next week. This post was first published on DevPostbyTruemark .

How to Connect With External MySQL Servers (Part 1: Select Operations)

There's a big hole in reusability on the web. An entertaining statistic - not the most accurate but still fascinating - was generated by Simon Wardley from a Twitter poll. He calculated that basic user registration had been written over a million times. The average developer had written user registration about 5 times. I'm sure you've built it a few times yourself. The solution to this would be to create a reusable 'package' for user registration. So why isn't there such a thing? It's a really interesting question, because if you could fix it, you could make web development so much faster. Three kinds of application The first problem is that user registration has both front end and back end elements. So you would need a package that included both of these. I think the closest to that would be a Wordpress plugin. PHP (on which Wordpress is built) mixes markup and processing on the back end. Although PHP doesn't have a neat way of packaging a group of pages and back end, you can do this in Wordpress. The problem though is that then you have to do everything else on your site using Wordpress. Empirically, people are still building registration over and over again, so the numbers tell us that's still quite a problem. But even so, this is key to the huge success of Wordpress on the web. Prebuilt application, plugin components The limitation Wordpress has is that it's a container that contains plugins. Whatever you build with Wordpress, it will still be a Wordpress site containing plugins, bits of your code, and your content. It won't be a mobile app (although it could get close these days). It won't be a data-backed web application. With Wordpress or with other conventional Content Management Systems, or with systems like Salesforce or Sharepoint, what you have is basically an application which you are able to extend and vary with plugins. You're limited in what functionality you can reuse with plugins, and because the application around them is fixed, you're limited in what the final application can do. This is the least flexible kind of environment I would identify for reuse. There are two other more flexible types. Custom application, library components The next is a module library for a programming language. The classic example I'd use here is NPM, the Node Package Manager, which has a huge range of almost entirely open source packages for programming in Javascript. Most programming languages have some equivalent. NPM itself reports the staggering statistic that its code makes up 97% of web applications which use it. Which if you think about it means that it makes those applications 33 times cheaper to develop. Clearly this is a very successful model of reuse. It does have some limitations. A code package clearly can only be used in the environment of the language in which it is written. However this is an environment which will let you build almost anything. Interestingly, despite being much more flexible in this way than something like Wordpress, I've never seen a software package for a whole user registration process. The reason is that packages tend to be either for front end or back end. More generally, there's still (even if it's only 3% of the total) quite a bit of custom coding required to glue code packages together, and a lot of this glue is very repetitive. This is mainly because code packages need a frame built around them to turn them into applications. Custom application, application components On to the next reuse environment. This is an environment for composing small applications into larger ones. A well-known example of this is shell scripting in Unix/Linux. It lets you script Linux commands, which are mostly little applications, into a more complex command i.e. application. These scripts are also a very successful model of reuse, having been used widely for decades. They are still in 2020 the most effective way of automating administrative work, a testament to how powerful they are. I don't know if it's ever been done, but I would guess the ratio of the lines of code in a script to the lines of code required to write the script's function from scratch would be better than 1:100. Pipelines If we look at the characteristics of Bash scripts, one remarkable property of them is how much work can be done with how little scripting. The model of composition they use is involves creating . pipelines This is a very common idiom widely used in many fields: the key idea is to have a range of functional components with a common interface between them. Obviously plumbing is the source of the term and plumbing components work very much like this. Electrical circuits, even lego bricks, make use of this concept. Its value is to create the highest possible degree of interoperability and interchangeability between components since because of the uniform interface, any group of components can be connected together. And also the new component formed by connecting others again has the same interface as an individual component itself. The 3 models of reuse So to summarise we have 3 models of reuse: Application with plugins as components Application built from library components Application built from application-components My argument here is that the last of these 3 is the most powerful. It is much more flexible and general than the first, because you can build any application rather than modifying one existing application by choosing plugins. It requires less effort and expertise than the second, because you don't have to write much code to glue everything together and to provide the wrapper needed to take a library into being an application. However you retain the flexibility of being able to build anything, especially when you allow for the custom coding of constituent applications. Pipelines are a key means of making it possible to compose applications like this. Pipelines on the web This all suggests that if there were a way of building pipelines on the web, and composing services to form bigger services, this could be a powerful way of approaching building for the web. The web is built on the client-server model. The client application (often a web browser) makes a request to a server which hosts the service, and receives a response. Requests and responses are both messages in the HTTP protocol. With only a minor restructure, this fits perfectly into the pipeline model because you have a common interface between your functional units which is the HTTP message. By sending the response from one service as a request to the next, you have a pipeline. And like with all good ideas, this has been done before. In fact with some success, but as yet in a very limited way. Yahoo Pipes This popular and innovative service was born from the enthusiasm for 'mashups' in 2007, combining data from multiple web sites and services. The service was directly inspired by Unix pipes (see the about this). Wiki page It created pipelines from single or multiple sources on the web and supplied built in processors to generate outputs. Sadly shut down in 2015, it inspired services such as IFTTT and Zapier which are popular today. of another service, import.io, describes this change. An article on the blog While Pipes was a successful tool, it was limited in how it fulfilled the possibilities of pipes and application composition on the web. While it could take input from the web, it couldn't output to the web or process using web services While it had the concept of pipes, it didn't let you use them to link web services. It was a closed system, not open to the web. IFTTT and Zapier These platforms which are widely used today work by creating event driven pipelines between services. They often form part of the back end functionality of no code projects. They wrap third party services with a common input/output interface, allowing the building chains of processors to for instance trigger SMS or emails when a certain log message arrives in a logging services. While these services create pipelines out of web services, they still have limitations: They can connect existing services, but they can't be used to create new APIs or services. The wrappers around services are not open and based on HTTP, but closed and only connectable within these platforms. A possible reason for the limitations of these services is the main difficulty with pipelines on the web: latency. Latency is the time between a request and the first arrival of the response. When we get to tens or hundreds of services in a pipeline, this delay builds up to the point where the pipeline is extremely slow. By containing the pipelines being built within the platform, these systems minimise this problem as latency is tiny within the same service. If they were open and the pipeline connections were being made between different services on the web, the much greater latency would become more of an issue. Serverless functions Another model which comes close to the ideal of pipelines in the web is the idea of serverless functions such as AWS Lambda. In fact the 'serverless' aspect of these functions is not the interesting part in relation to this. The concept of a function which transforms a web request into a web response and which is published on the web and accessible at a URL is a core element of what I am proposing. Many have expected serverless functions to form a basis for reuse on the web, however this hasn't materialised to any real degree. This is due to these limitations of serverless functions: While latency between serverless functions within the same cloud platform is low, they have a so-called 'cold start' delay. The platform on which these functions run has to start the code for the function on a physical server every time it is called. It then keeps that code around for a short while before removing it again: if another request for that function comes in during that time it can immediately satisfy it, but otherwise it has to pay the startup cost again. This delay while counted in milliseconds can be signficant and is quite variable. A chain of serverless functions could create a very significant delay. Another issue with serverless functions calling one another is that they are paid for on the basis of the time they are running. When one invokes another and it has to wait for the response, both are active and being paid for. This is less of a problem for building pipelines as a pipeline manager can call one function, get the result, end the function and send the result to the next etc. The Yahoo Pipes based platforms all provide a number of internal basic services for e.g. transforming data between one step and the next. There's nothing of this kind for Serverless functions as they were never really conceived of as an environment for composition. Setting up a serverless function takes a signficant time and while AWS has a service called Step Functions which helps with composition, working with serverless functions is not nearly as simple as the drag and drop style functionality provided by Yahoo Pipes and friends. The new model Combining the best aspects of these prior examples and adding some new ideas leads to a new model of pipelines for the web which resolves their limitations and brings this concept to its full power. A name for this model is a . service space Runtime The functions of this new model are provided by a , i.e. a piece of code which can be installed on different servers with different characteristics, or even run within a serverless function. This means it's possible either to both provide a platform which manages the runtime and the servers on which it is running (making it a serverless service), or to control how and where the runtime runs yourself, adding more flexibility. runtime Multiple services on one server The runtime hosts a number of services on one server in one process. These services have internal routing which lets them message each other with zero overhead. Latency cost only exists for calls from one server to another. This greatly reduces the issue of latency in a complex service pipeline. The services which exist, the url paths on which they are accessed, and their configuration are specified in a configuration file. Services provide an HTTP interface The interface to every service is that it receives an HTTP message and emits another HTTP message, allowing them to be pipelined together. HTTP messages are standarised somewhat to improve interoperability. The key standardisation is on JSON as the data representation. HTTP message can then have essentially 3 types of body: binary data, text data or JSON. Services are hosted on URLs and open to the web Every service on a server is configured on a URL within that server's domain, and so can be called across the web. Authentication is built-in and can be used to restrict access where required. This means it's possible to call any service or pipeline made of services like any other service on the web. Referential transparency The model provides this useful quality of a distributed system which means that if you have a reference to a service (which is its URL), you don't care about where it is running. This is provided by a simple built-in service that simply forwards a web request from one server to another. This makes it possible to move a service on a runtime on one server to the runtime on another server simply by replacing it with this forwarding service which means the service you moved can still be found on the same URL. This ability to transparently distribute services where you like simplifies scaling and helps to run workloads on appropriate infrastructure. Library of core and custom-built services The model requires that you have a central public library of service code. A runtime can pull the code for any service it needs to run from this library. The runtime itself contains a core set of services that provide for such things as constructing pipelines from other services, storing data, authentication etc. The library can be extended by user contribution. Private libraries can exist for teams to share their service code. It will be possible for all or nearly all the services needed to be library services, just leaving the job of configuring the services themselves. Uniform interfaces to functionality Another desirable property of this platform is that it should define consistent APIs to common functionality. For instance, the basic API for data storage should be that data is written to a URL via a PUT request, then read back from the URL via a GET request. The best way to structure this is that a service exists to provide this interface, into which you then plug drivers for different underlying data sources, whether it be file storage, a relational database, a NoSQL database etc. You can then access the more powerful features of the underlying data source such as querying or search though a separate service. User interface Services contain their own documentation and advertise which consistent APIs they provide. This then enables a modular user interface which is built of modules which provide user interaction with those APIs, as well as overall configuration for runtimes. As an example of a consistent API, many services will store files and data for their use in different ways, and expose these on URLs. The UI should allow those files and data to be navigated, edited, created and deleted. Discussion and examples As part of creating and investigating this model, a runtime named Restspace has been created ( ). The documentation can give an idea of how a platform like this can work in practice. It's a work in progress and lacks certain aspects of the model as yet. https://restspace.io It's striking how fast it is possible to build a wide range of web services, APIs and websites using a system like this. So how do you reuse user registration? Here's a way it could work with Restspace. A special service mediates changes to the configuration of each server. When a service is added via this service, it ensures any other services it depends on are also present in the configuration. Adding user registration simply involves simply adding a user registration service. This provides a url on which there is a script file which builds the registration user interface on the browser. As dependencies of the user registration service we have the authentication service and the user store service which are added if necessary when the user registration service is added. The script knows where it can find the user store (which includes a JSON Schema which specifies the fields of a user record) and adds a new user record when a site user registers. Conclusion A number of past and present web platforms have attempted to foster reuse and composition of web services, but have had partial success. The most successful approaches to reuse involve composition of applications. In the realm of the web, composition is best done by the creation of pipelines of web services. A system which fully realises the possibilities in this space needs a number of elements and capabilities in place as listed above. I propose the way forward is the model outlined in this article. Previously published at https://restspace.io/blog/Web%20reusability-%20a%20new%20way

Did you know you could write scripts with webservices? You do now.

I am sure that you already have Zoom, Slack and Asana on your computer. But daily office life is more than written tasks and planned meetings. There are lunches with your team, spontaneous talks near the water cooler, common tasks and goals you want to acheive. It’s your comfortable workplace and it by itself motivates you to be productive. Just look at the bunch of stickers on the wall — big things are waiting for you! After we all switched to remote work, many of these processes disappeared from our lives. But it seems to me that we can move them online . Life in office has a lot of invisible and important processes in it. painlessly So let’s talk about these processes and the tools that help us recreate the office vibe at home! The ones that help remote teams keep in touch, talk to each other more and don’t miss the opportunities they could have in the office. p.s. You will not find tools here. And I did it in purpose. very popular How to create the atmosphere of the office home Try TandemChat . it’s a virtual office — you can quickly interact with colleagues, spontaneously call them and work together on the same platforms (Trello, Notion, Google Docs, etc.) Description: , , , [not launched yet], [not launched yet], [not launched yet]. Analogs: RemoteHQ Teemly Pragli Makespace With wfhland How to recreate the feeling of the meeting in one place Try HighFidelity . virtual spaces that simulate real meetings. Description: , . Analogs: Connect.club Airmeet How to recreate the small talks before the meetings Try Brightful . short games / quizzes that are designed to help the participants of the meeting to find connection with each other in a friendly way. Description: How to replace the meeting-boards that help you find the best decisions Try Ment . A visual platform that simplifies decision-making for teams. Description: How to recreate the opportunity to meet colleagues spontaneously (and not only colleagues) Try . NextPage An app that allows you to meet spontaneously online with colleagues and friends. Description: How to recreate the tradition to put stickers on the board Try Parabol . : software for conducting online retrospectives. Description How to transfer the coffee breaks from offline to online With Hallway . A Slack bot that automatically allocates time for joint coffee breaks. Description: How to recreate the code cross-editing process Try GitDuck . : tools for developers that enables to talk, share your code and do pair programming with ease. Description How to recreate the feeling of being idle in front of colleagues Try Focusmate . “virtual coworking” — where you can easily find a “colleague”, and monitor the concentration and productivity of each other. Description: How to replace meeting moderator Try Macro . : an add-on for video calls services (Zoom, Meet) that helps make meetings more efficient. Description How to recreate the daily stand-up’s with your teammates Try Standups . “stories for stand-ups” — update each other regardless of their time zone or location, using async video & voice messages. Description: How to replace assistant who makes meeting notes Try Hugo . : An app that makes it easy to create, store, and collaborate on notes after a meeting. Description How to recreate an opportunity to share emotions during meetings Try . Nod extension for Google Chrome that allows you to exchange emotions during Google Meet calls. Description: How to replace assistant who helps you with your schedule Try . Clockwise : An app for G-Suite that optimizes your calendar, searching for a best time for a focused work. Description How to replace meetings, yep, all the meetings (even virtual ones) Try [not launched yet, but seems promising — from creators of Meerkat и Houseparty] SlashTalk : it is not clear yet, but their manifesto says that they want to decentralize communication within the teams completely. Description

20+ Extraordinary Apps For Remote Teams

With Docker Desktop running on WSL 2, users can leverage Linux workspaces and avoid having to maintain both Linux and Windows build scripts. How is it different? Applications that run on docker are limited to applications that are natively supported by the host operating system. In other words, Docker for Windows can only host Windows applications inside Docker containers, and Docker on Linux supports only Linux apps. Docker on Windows: Challenges Docker on windows always has been a challenge, earlier when I first used Docker back in 2017 it had following limitations, It had a strict requirement of Windows versions that are supported, several containers were not available for windows platform. Support for the orchestration systems like Kubernates and Mesos was not complete. Most of this was related to the fact that Docker was originally written and built for Linux. There were a few workarounds to make it work on WSL (Windows Subsystem for Linux) but they were complicated and not complete. Windows Subsystem for Linux (WSL) 2 introduces a significant architectural change as it is a , allowing Linux containers to run natively without emulation. full Linux kernel built by Microsoft Starting with WSL2, Docker can run in it’s full flow in Windows and you can use images built for Linux. Below tutorial will help you install Docker on your WSL in windows. Prerequisites Before you install the Docker Desktop WSL 2 backend, you must complete the following steps: Install Windows 10, version 2004 or higher (Build 19041 or higher). At the moment of writing this article, to update to Windows 10 version 2004 (Build 19041), you will need to join the Windows Insider program and select the “Release Preview” ring. The public release should arrive by late May. Enable WSL 2 feature on Windows. Open PowerShell as Administrator and run: dism.exe /online /enable-feature /featurename :Microsoft-Windows-Subsystem-Linux /all /norestart Enable the ‘Virtual Machine Platform’ optional component Open PowerShell as Administrator and run: dism.exe /online /enable-feature /featurename :VirtualMachinePlatform /all /norestart Restart your machine at this point to complete the WSL install and update to WSL 2. Install the linux kernel package required to update the WSL version to WSL 2. Details of kernel are in below link, https://docs.microsoft.com/en-us/windows/wsl/wsl2-kernel Installer is at, https://wslstorestorage.blob.core.windows.net/wslblob/wsl_update_x64.msi Set WSL 2 as your default version Open PowerShell as Administrator and run: wsl -- - -version set default 2 Install your Linux distribution of choice Open the Microsoft Store and select your favorite Linux distribution. Some of the popular one’s are below : Ubuntu SUSE Linux Enterprise Server The first time you launch a newly installed Linux distribution, a console window will open and you’ll be asked to wait for a minute or two for files to de-compress and be stored on your PC. All future launches should take less than a second. You will then need to create a user account and password for your new Linux distribution. Check for the list of linux distributions, wsl -l -v Set the distribution to use WSL 2 wsl -- - <distribution name> set version <versionNumber> Installing Docker Desktop Download . Docker Desktop Stable 2.3.0.2 or a later release Make sure to select below during installation, Run Docker Desktop. That’s it. You have now installed docker on WSL 2. Verify it by running it in Ubuntu/Linux terminal. Configure Docker container limits in WSL2 WSL 2 also allows us to configure memory and processors in below config, this can be controlled in case you want to limit resources used by your docker containers. Add file for tweaking WSL2 settings %UserProfile%\.wslconfig [wsl2] =<path> # An absolute Windows path a custom Linux kernel. =<size> # How much memory assign the WSL2 VM. =<number> # How many processors assign t
he WSL2 VM. =<size> # How much swap space the WSL2 VM. 0 swap file. =<path> # An absolute Windows path the swap vhd. =<bool> # Boolean specifying ports bound wildcard localhost the WSL2 VM should be connectable the host via localhost:port (default ). kernel to memory to to processors to to swap to add to for no swapFile to localhostForwarding if to or in from true Test Docker: Getting-Started From the official documentation of Docker, lets test Getting-Started guide. git ://github.com/docker/getting- .git clone https started Run below commands to build docker image, Note that we are running this in WSL terminal of your linux distro. Run docker run -d -p : --name docker-tutorial docker101tutorial 80 80 Open browser and type http://localhost/ You should see the getting started guide. That’s it folks, we have successfully installed and tested Docker on WSL2. I will test more features of Docker on WSL2 and update the article but the above steps should give you a head start to use Linux images in docker for windows. Previously published at https://medium.com/codingfullstack/run-docker-linux-containers-natively-on-windows-subsystem-for-linux-4517584c86f5

How To Run Docker Linux Containers Natively on Windows

Cómo ejecutar contenedores Docker Linux de forma nativa en Windows

Interoperability is a big word with even bigger connotations for the cryptosphere. In Fact, apart from the burgeoning , no other industry vertical is attracting so much investment and interest. DeFi movement What is Interoperability? Essentially, interoperability is all about making crypto networks compatible with one another. By doing so, it is expected to unlock a world in which value can be transferred seamlessly across seperate chains and smart contracting languages, while capitalizing on the strengths that are inherent to each protocol. Crypto Projects Are Racing to Crack the Interoperability Problem Given that crypto networks have been incompatible with one another since day one, why so much hurry to solve the problem now? While attempts at bridging protocols have been made numerous times, in the last 18 months, developers have been actively competing to find a way.  Currently, a few projects are moving ahead with plans to roll out proprietary solutions in the works. There are many reasons fr this new found urgency. Mainly, the project to ship a viable solution for bridging major crypto networks first is most likely to dominate the market. Ethereum isa good example of this: it might not be the most user-friendly or scalable smart contracting blockchain, but its first mover advantage for developers cannot be overlooked. There’s more than one way to cook an egg, and as the following projects working on three of the leading blockchains are demonstrating, there’s more than one way to achieve interoperability. Bitcoin: RSK and Syscoin and Syscoin both utilize merge mining to tap into Bitcoin’s unparalleled security model, while providing a bridge to other protocols. In the case of RSK, this is achieved through RSK Infrastructure Framework Open Standard (RIF OS), a series of open protocols for dApp development. It provides interoperability between different blockchains, enabling developers to create applications that draw upon the strengths of specific crypto networks. Examples of RSK’s interoperability in action in solutions like the Lumino Network, which creates payment channels for every token issued on RSK, facilitating cross-token payments and providing full interoperability with the . RSK can be seen Lightning Network is also looking to bridge the gap between Bitcoin and other crypto networks – primarily Ethereum. It achieves this through Syscoin Bridge, which provides trustless interoperability, making it easy to move from one protocol to another without requiring a mediator. Jagdeep Sidhu, Core Developer and Syscoin Foundation Chairman, explains: “The Syscoin developers have chosen Ethereum as the first integration for two reasons: to enable new and existing Syscoin Platform Tokens with Ethereum's time-tested smart contracts and toolkits, and to help address Ethereum Network's growing need for a viable scaling solution by giving ERC20s access to fast, secure, low-cost transactions on a scalable layer.” Syscoin Ethereum and EOS: LiquidApps What RSK and Syscoin are doing for Bitcoin-Ethereum, is doing for Ethereum-EOS. Just like RSK aims to make dApps connectable to any crypto network, LiquidApps is the creation of multi-chain dApps. This is done via the originally named DAPP Network, making it cheaper to develop, launch and scale dApps. LiquidApps facilitating To understand it better, think of EOS and Ethereum like Android and iOS. LiquidApps enables developers to launch dApps on both operating systems simultaneously, without having to substantially rebuild the application in the process. The DAPP Network also reduces resource costs, which can get expensive on EOS for high volume dApps. LiquidApps takes much of this off-chain, significantly increasing efficiency. LiquidLink, is the company’s solution for integrating dApps with multiple blockchains. Data and assets from chains such as Telos, Ripple, Stellar, Tron, Cardano, and Bitcoin Cash can all be fed into dApps using LiquidLink. To Interoperability and Beyond The next step in the development of interoperability solutions will be the creation of pan-protocol products that can effectively unite all the chains under one banner. It may sound utopic, but this has got to be the endgame for crypto networks: complete compatibility and interconnectedness, enabling blockchains to overcome the sort of barriers that are synonymous with the traditional financial world. There are regulatory and protectionist reasons why payment networks such as Visa fiercely protect their payment rails. In crypto, however, there is no justifiable reason for crypto networks to be siloed. Lowering barrieres to entry will be good for consumers and businesses alike,  which is why everyone is looking for a way to make this a reality. However, there is still a way to go before this vision is actualized. While companies such as Wanchain, Cosmos and Quant Network are pressing ahead with solutions, AI-based PoS chain is making significant  inroads themselves. Through clever usage of game theory and Artificial Intelligence, the project aims to align incentives between network contributors, while providing a connection to multiple blockchains and a reputation mechanism to prevent cartels from forming. It’s already implemented within the Velas wallet, with full cross-chain compatibility within reach. Velas inter-chain token transfers When the interopability race is over there will be companies who triumph and ones who fail. However, for the industry at large and the end users, the exciting thing will be the possibilities of interoperability realized which will be a major game changer for all.

Crypto Projects Are Racing to Crack the Interoperability Problem

On the 11th of September, published an article with the title . To pick the answer from the article — ! Hacked.com ‘How Many Blockchains Does The Future Hold?’ too many “We’ve seen the successful execution of dozens upon dozens of ICOs on the Ethereum platform. In too many cases, these ICOs just wind up being a useless token of thanks and their value tends toward zero.” However, in plenty of cases, this currency is crucial in the ecosystem they have built. The problem here is that we have too many projects all trying to accomplish similar goals. Predictions for 2019 say we will see more collaborations hosting one currency integrated into multiple projects. Still, this is only a mediocre solution as many of the projects are too stubborn or far-fetched to drop their beloved ecosystem currency. What can we do? This article proposes a view of the different possible interconnectivity solutions. The lack of interconnection between blockchains means that you cannot choose the best features from multiple blockchains. Interledger Protocol — Payments Across Payment Networks is made up of a network of connectors, independent operators that act as decentralized exchanges or market makers for cryptocurrencies, fiat currencies, and other tokenized assets. The protocol allows users to transact natively on the network of their choice, without needing to move assets to a centralized exchange or to a specific blockchain for trading. The protocol is created out of the idea to facilitate a universal network for sending value, independent of any company or currency. Interledger Ripple’s David Schwartz recently released a blog post on Ripple’s ‘Insight’ page on why open payment protocols will be the first step in changing payment and settlement systems across the world. He believes, “By connecting bank ledgers and existing infrastructure investments via Interledger Protocol (ILP), banks are taking the first steps in improving global payments today — and in enabling a true Internet of Value.” The ILP has also been incorporated into Ripple’s XCurrent product which enables users to make cross-border payments. This progress is in line with the privacy, speed, and flexibility needs expressed by Ripple’s roadmap. ILP meets these needs by allowing for instant and certain transactions to be processed across an infinite number of ledgers. MESG — IFTTT For Blockchain Connectivity A project called is working on “the new economy of app development” by providing connectable and reusable integrations from any API or decentralized network. It acts like an “If This, Then That” for blockchain interconnectivity. Let’s find out why? MESG MESG is developing tools that enable non-coders to automate workflows with the integration of blockchain technologies wherein widely used apps exchange data and performing specific, prescribed actions whenever a trigger/event occurs. Using these paradigms, known as Event Driven and Service Oriented Architectures, and Flow Based Programming, even a non-technical user can connect data from an event or a task to the input of another task. Many apps today consist largely of connections between different APIs or different technologies, and yet the way they connect and interact with each other is still extremely complicated. The MESG Engine makes connecting all these components far easier, enabling developers and businesses to create better, more scalable applications faster. Interchain Providing Blockchain Agnostic Business Logic The project provides smart contracts to watch a particular blockchain of the user’s choice for incoming transactions or fire smart contracts on another public blockchain like NEO. To give you a better image of its capabilities, consider this use case. Interchain “A small grocery store uses multiple suppliers to get their product. Each supplier uses a different blockchain to complete their transactions on; one uses Ethereum, another uses NEO, and another uses Ark. The store does not want to commit to one blockchain over another. Instead, the store uses Dragonchain to monitor each blockchain. With Dragonchain’s Interchain, the store is able to monitor transactions and interact with different blockchains all in one place and implement business logic agnostic to whatever blockchain is being used.” Atomic Swap Technology At last, atomic swap technology allows us to interchange different cryptocurrencies or tokens without the risk of one party defaulting on the trade using cryptographically powered smart contract technology. In fact, it contributes to the interconnectivity of different chains as it gives users a mean to trustlessly exchange tokens without going through a centralized service. TLDR; Put simply, atomic swaps, or atomic cross-chain trading, is the exchange of one cryptocurrency to another cryptocurrency, without the need to trust a third-party. A relatively new piece of technology, atomic cross-chain trading is looking to revolutionize the way in which users transact with each other. Source . Tweet Ending Notes What is the importance of interconnectivity in the blockchain space? How will projects benefit? There are new blockchains and decentralized technologies created every day for different purposes. But without any means of connecting these different technologies, creating applications that utilize them will be really difficult to achieve. The lack of interconnection between blockchains means that you cannot choose the best features from multiple blockchains, so most choose a single blockchain that has the best average capabilities and does a bit of everything. Do businesses need IFTTT-like solutions? Co-founder Anthony Estebe of MESG thinks businesses love these solutions because it lets one create or optimize certain workflows quickly, even with limited technical skills. With very little training, businesses can “automate away” all sorts of tasks which are menial, basic and repetitive, but also absolutely critical to a business’s success. Source image: Hypestar.uk MESG also lets businesses connect to, and interact with, different ecosystems by spanning disparate communication channels, which enables creativity and can lead to business opportunities and growth. Anthony believes these solutions are the future, that 90% of applications development will leverage this basic concept. This is why MESG can be so important, it pushes the limits of IFTTT-like solutions to the next level, secured by a real economy to grow and stabilize the ecosystem and still allowing this interoperability by design because of the event-based philosophy. When it becomes easy to connect a technology, and the technology is good, adoption follows.

Meet the IFTTT of Blockchain Technology

Connected devices are proliferating our homes with fridges, light bulbs, watches, (and soon) plants, bins, and who-knows-what streams of data around the globe. Ignoring the question of a need for connected devices, one of the significant issues with the number of devices is all the competing apps, standards, and platforms that you need to manage. Each device manufacturer generally needs its own application, of varying quality, and with some devices reporting duplicate information, how do you make your connected home a smart home? that aim to do just that, uniting connected devices into one platform and allowing you to manage them and view their data in one place. One of the options I featured was , and being a local business, they offered me a variety of devices to test the platform thoroughly and report back on what I found. I recently reviewed a list of platforms Conrad Connect Conrad Connect follows similar paradigms to other connected devices platforms, with triggers and data points for devices and outputs, such as messaging systems, spreadsheets, IFTTT, and more. All of these devices are connectable with a drag and drop interface that is relatively easy for anyone to use, but with some polish needed. The team behind the project is operating as a start-up within the company and making changes quickly. Devices and Use Cases First, I’ll cover the devices I tested, as even with a platform that attempts to improve your experience with them, some devices offer more to integration platforms than others. Spotcam Sense makes a range of connected cameras for a variety of purposes, but mostly for security. I am not too fussed about security monitoring, so I instead opted to set up a camera that watched for whenever our cat went to eat its food, logging the times in a spreadsheet and recording a photo. Spotcam The Spotcam device is well made and comes with brackets to mount the camera in a way that suits you. The software, however, leaves a lot to be desired. The web client requires you to install Flash, and I have not encountered an application that needed Flash for a very long time. Considering they also have iOS and Android applications available I couldn’t understand why the web client needed a piece of software that is verging on being abandoned by its creators. With Flash installed the interface is still sluggish, outdated and ugly, the mobile apps aren’t much better, but they get the job done. Another negative of the platform is that it claims brazenly on the box to give you access to a “free secured cloud — forever,” but this isn’t entirely true. To keep recordings for more than a day (which realistically is what you need), you have to pay. To use any of the AI services to spot people or animals, you need to pay. All in all, this makes the camera somewhat useless without buying a handful of their subscription packages. Not to worry, Conrad Connect means that at least you can capture key moments from the camera. I added the device source by connecting my Spotcam account to my Conrad Connect account, selecting the trigger events, where I want to send the data to, and the data I want to send. You can have multiple inputs and outputs and chain them together, my final cat cam project sends data to an Excel spreadsheet, and sent me an email everytime the cat had something to eat. Wiz Smart Lights produces a range of smart bulbs for different lamp sizes and types. They are well made, and the app is also well developed and offers a lot of functionality. Unfortunately, they don’t expose a lot of this functionality to 3rd parties, such as Alexa, Google Assistant, and Conrad Connect. I recently spoke to a member of their staff at IFA, and they acknowledged this as a shortfall they are fixing soon. Wiz Conrad Connect currently only has access to the or state of Wiz lamps, and not any of the scenes or fine-grained controls. This does mean that you can use external triggers, such as the time, weather, or Slack, to switch the lamps on and off into their default setting. on off Sygonix Smart Sockets As far as I can tell, Sygonix is a Conrad house brand for a series of connected power sockets. As they are relatively generic Chinese products, the hardware and software aren’t great, and they aren’t that pretty. As plugs in Europe don’t have switches, these were the devices I was most keen on trying, so I could switch devices off from the socket. It was only when I started to set the plugs up did I realize that maybe I had got used to having sockets with no switches, and I struggled to find any valid use cases for them. I also wondered if the power overhead of maintaining a Wi-Fi module (which is a concern for many connected devices) was higher than having a device in standby mode. I noticed that Conrad Connect had a value for the sockets for the wattage, which seemed to be a great way of monitoring device consumption. I connected the output to a spreadsheet and defined the range I’d like to check for, but I could never get any values apart from 0, so I’m not sure what I got wrong. General Thoughts Conrad Connect has elements in common with a lot of the platforms featured in my earlier post as well as less visual and more general tools, such as . The combination of a workflow builder and visual output is a compelling combination for those who want to see everything in one place. Figuring out how to trigger events takes a lot of trial and error, and response times from some devices and services was slow at times. IFTTT I am still trying to find the perfect use cases for connected devices in my life, but using Conrad Connect helped me explore the potential, I was especially pleased with the Wiz light bulbs, which I am now regularly using. The platform needs some work, but it’s nice to have a European option on the market backed by a company with years of expertise. It’s something of a genius move from a company that owns a large retail business selling electronics to create a platform that connects many of them. During a recent conversation I had with the project lead, I was told that in addition to this source of revenue, and premium accounts (that allow you to create more projects), they also intend to explore affiliate revenue from subscription services. This idea fits back into where I opened this article, needing a platform to help you filter and manage all the information your devices are gathering and all the requests they are making. You can listen to an interview with Andreas Bös, the senior director of Conrad Connect below. Originally published at dzone.com .

Stories, News & Mentions about CONNECTBLUE

Connectblue’s Stories on HackerNoon

Connectblue's News & Mentions