Clearwordis in the Enterprise Collaboration Industry

Clearword

clearword

The Unbearable Weight of a Family's Crisis

The Moon Metal by Garrett Putman Serviss is part of the HackerNoon Books Series. You can jump to any chapter in this book here. THE LOOTING OF THE MOON THE LOOTING OF THE MOON I shall spare the reader a recital of the tireless efforts, continuing through many almost sleepless weeks, whereby Andrew Hall obtained his clew to Dr. Syx’s method. It was manifest from the beginning that the agent concerned must be some form of etheric, or so-called electric, energy; but how to set it in operation was the problem. Finally he hit upon the apparatus for his initial experiments which I have already described. “Recurring to what had been done more than half a century ago by Hertz, when he concentrated electric waves upon a focal point by means of a concave mirror,” said Hall, “I saw that the key I wanted lay in an extension of these experiments. At last I found that I could transform the energy of an engine into undulations of the ether, which, when they had been concentrated upon a metallic object, like a chunk of gold, imparted to it an intense charge of an apparently electric nature. Upon thus charging a metallic body enclosed in a vacuum, I observed that the energy imparted to it possessed the remarkable power of disrupting its atoms and projecting them off in straight lines, very much as occurs with a kathode in a Crookes’s tube. But—and this was of supreme importance—I found that the line of projection was directly towards the apparatus from which the impulse producing the charge had come. In other words, I could produce two poles between which a marvellous interaction occurred. My transformer, with its concentrating mirror, acted as one pole, from which energy was transferred to the other pole, and that other pole immediately flung off atoms of its own substance in the direction of the transformer. But these atoms were stopped by the glass wall of the vacuum tube; and when I tried the experiment with the metal removed from the vacuum, and surrounded with air, it failed utterly. “This at first completely discouraged me, until I suddenly remembered that the moon is in a vacuum, the great vacuum of interplanetary space, and that it possesses no perceptible atmosphere of its own. At this a great light broke around me, and I shouted ‘Eureka!’ Without hesitation I constructed a transformer of great power, furnished with a large parabolic mirror to transmit the waves in parallel lines, erected the machinery and buildings here, and when all was ready for the final experiment I telegraphed for you.” Prepared by these explanations I was all on fire to see the thing tried. Hall was no less eager, and, calling in his two faithful assistants to make the final adjustments, he led the way into what he facetiously named “the lunar chamber.” “If we fail,” he remarked with a smile that had an element of worriment in it, “it will become the ‘lunatic chamber’—but no danger of that. You observe this polished silver knob, supported by a metallic rod curved over at the top like a crane. That constitutes the pole from which I propose to transmit the energy to the moon, and upon which I expect the storm of atoms to be centred by reflection from the mirror at whose focus it is placed.” “One moment,” I said. “Am I to understand that you think that the moon is a solid mass of artemisium, and that no matter where your radiant force strikes it a ‘kathodic pole’ will be formed there from which atoms will be projected to the earth?” “No,” said Hall, “I must carefully choose the point on the lunar surface where to operate. But that will present no difficulty. I made up my mind as soon as I had penetrated Syx’s secret that he obtained the metal from those mystic white streaks which radiate from Tycho, and which have puzzled the astronomers ever since the invention of telescopes. I now believe those streaks to be composed of immense veins of the metal that Syx has most appropriately named artemisium, which you, of course, recognize as being derived from the name of the Greek goddess of the moon, Artemis, whom the Romans called Diana. But now to work!” It was less than a day past the time of new moon, and the earth’s satellite was too near the sun to be visible in broad daylight. Accordingly, the mirror had to be directed by means of knowledge of the moon’s place in the sky. Driven by accurate clockwork, it could be depended upon to retain the proper direction when once set. With breathless interest I watched the proceedings of my friend and his assistants. The strain upon the nerves of all of us was such as could not have been borne for many hours at a stretch. When everything had been adjusted to his satisfaction, Hall stepped back, not without betraying his excitement in flushed cheeks and flashing eyes, and pressed a lever. The powerful engine underneath the floor instantly responded. The experiment was begun. “I have set it upon a point about a hundred miles north of Tycho, where the Yerkes photographs show a great abundance of the white substance,” said Hall. Then we waited. A minute elapsed. A bird, fluttering in the opening above, for a second or two, wrenched our strained nerves. Hall’s face turned pale. “They had better keep away from here,” he whispered, with a ghastly smile. Two minutes! I could hear the beating of my heart. The engine shook the floor. Three minutes! Hall’s face was wet with perspiration. The bird blundered in and startled us again. Four minutes! We were like statues, with all eyes fixed on the polished ball of silver, which shone in the brilliant light concentrated upon it by the mirror. Five minutes! The shining ball had become a confused blue, and I violently winked to clear my vision. “At last! Thank God! Look! There it is!” It was Hall who spoke, trembling like an aspen. The silver knob had changed color. What seemed a miniature rainbow surrounded it, with concentric circles of blinding brilliance. Then something dropped flashing into an earthen dish set beneath the ball! Another glittering drop followed, and, at a shorter interval, another! Almost before a word could be uttered the drops had coalesced and become a tiny stream, which, as it fell, twisted itself into a bright spiral, gleaming with a hundred shifting hues, and forming on the bottom of the dish a glowing, interlacing maze of viscid rings and circlets, which turned and twined about and over one another, until they had blended and settled into a button-shaped mass of hot metallic jelly. Hall snatched the dish away, and placed another in its stead. “This will be about right for a watch charm when it cools,” he said, with a return of his customary self-command. “I promised you the first specimen. I’ll catch another for myself.” “But can it be possible that we are not dreaming?” I exclaimed. “Do you really believe that this comes from the moon?” “Just as surely as rain comes from the clouds,” cried Hall, with all his old impatience. “Haven’t I just showed you the whole process?” “Then I congratulate you. You will be as rich as Dr. Syx.” “Perhaps,” was the unperturbed reply, “but not until I have enlarged my apparatus. At present I shall hardly do more than supply mementoes to my friends. But since the principle is established, the rest is mere detail.” Six weeks later the financial centres of the earth were shaken by the news that a new supply of artemisium was being marketed from a mill which had been secretly opened in the Sierras of California. For a time there was almost a panic. If Hall had chosen to do so, he might have precipitated serious trouble. But he immediately entered into negotiations with government representatives, and the inevitable result was that, to preserve the monetary system of the world from upheaval, Dr. Syx had to consent that Hall’s mill should share equally with his in the production of artemisium. During the negotiations the doctor paid a visit to Hall’s establishment. The meeting between them was most dramatic. Syx tried to blast his rival with a glance, but knowledge is power, and my friend faced his mysterious antagonist, whose deepest secrets he had penetrated, with an unflinching eye. It was remarked that Dr. Syx became a changed man from that moment. His masterful air seemed to have deserted him, and it was with something resembling humility that he assented to the arrangement which required him to share his enormous gains with his conqueror. Of course, Hall’s success led to an immediate recrudescence of the efforts to extract artemisium from the Syx ore, and, equally of course, every such attempt failed. Hall, while keeping his own secret, did all he could to discourage the experiments, but they naturally believed that he must have made the very discovery which was the subject of their dreams, and he could not, without betraying himself, and upsetting the finances of the planet, directly undeceive them. The consequence was that fortunes were wasted in hopeless experimentation, and, with Hall’s achievement dazzling their eyes, the deluded fortune-seekers kept on in the face of endless disappointments and disaster. And presently there came another tragedy. The Syx mill was blown up! The accident—although many people refused to regard it as an accident, and asserted that the doctor himself, in his chagrin, had applied the match—the explosion, then, occurred about sundown, and its effects were awful. The great works, with everything pertaining to them, and every rail that they contained, were blown to atoms. They disappeared as if they had never existed. Even the twin tunnels were involved in the ruin, a vast cavity being left in the mountain-side where Syx’s ten acres had been. The force of the explosion was so great that the shattered rock was reduced to dust. To this fact was owing the escape of the troops camped near. While the mountain was shaken to its core, and enormous parapets of living rock were hurled down the precipices of the Teton, no missiles of appreciable size traversed the air, and not a man at the camp was injured. But Jackson’s Hole, filled with red dust, looked for days afterwards like the mouth of a tremendous volcano just after an eruption. Dr. Syx had been seen entering the mill a few minutes before the catastrophe by a sentinel who was stationed about a quarter of a mile away, and who, although he was felled like an ox by the shock, and had his eyes, ears, and nostrils filled with flying dust, miraculously escaped with his life. After this a new arrangement was made whereby Andrew Hall became the sole producer of artemisium, and his wealth began to mount by leaps of millions towards the starry heights of the billions. About a year after the explosion of the Syx mill a strange rumor got about. It came first from Budapest, in Hungary, where it was averred several persons of credibility had seen Dr. Max Syx. Millions had been familiar with his face and his personal peculiarities, through actually meeting him, as well as through photographs and descriptions, and, unless there was an intention to deceive, it did not seem possible that a mistake could be made in identification. There surely never was another man who looked just like Dr. Syx. And, besides, was it not demonstrable that he must have perished in the awful destruction of his mill? Soon after came a report that Dr. Syx had been seen again; this time at Ekaterinburg, in the Urals. Next he was said to have paid a visit to Batang, in the mountainous district of southwestern China, and finally, according to rumor, he was seen in Sicily, at Nicolosi, among the volcanic pimples on the southern slope of Mount Etna. Next followed something of more curious and even startling interest. A chemist at Budapest, where the first rumors of Syx’s reappearance had placed the mysterious doctor, announced that he could produce artemisium, and proved it, although he kept his process secret. Hardly had the sensation caused by this news partially subsided when a similar report arrived from Ekaterinburg; then another from Batang; after that a fourth from Nicolosi! Nobody could fail to notice the coincidence; wherever the doctor—or was it his ghost?—appeared, there, shortly afterwards, somebody discovered the much-sought secret. After this Syx’s apparitions rapidly increased in frequency, followed in each instance by the announcement of another productive artemisium mill. He appeared in Germany, Italy, France, England, and finally at many places in the United States. “It is the old doctor’s revenge,” said Hall to me one day, trying to smile, although the matter was too serious to be taken humorously. “Yes, it is his revenge, and I must admit that it is complete. The price of artemisium has fallen one-half within six months. All the efforts we have made to hold back the flood have proved useless. The secret itself is becoming public property. We shall inevitably be overwhelmed with artemisium, just as we were with gold, and the last condition of the financial world will be worse than the first.” My friend’s gloomy prognostications came near being fulfilled to the letter. Ten thousand artemisium mills shot their etheric rays upon the moon, and our unfortunate satellite’s metal ribs were stripped by atomic force. Some of the great white rays that had been one of the telescopic wonders of the lunar landscapes disappeared, and the face of the moon, which had remained unchanged before the eyes of the children of Adam from the beginning of their race, now looked as if the blast of a furnace had swept it. At night, on the moonward side, the earth was studded with brilliant spikes, all pointed at the heart of its child in the sky. But the looting of the moon brought disaster to the robber planet. So mad were the efforts to get the precious metal that the surface of our globe was fairly showered with it, productive fields were, in some cases, almost smothered under a metallic coating, the air was filled with shining dust, until finally famine and pestilence joined hands with financial disaster to punish the grasping world. Then, at last, the various governments took effective measures to protect themselves and their people. Another combined effort resulted in an international agreement whereby the production of the precious moon metal was once more rigidly controlled. But the existence of a monopoly, such as Dr. Syx had so long enjoyed, and in the enjoyment of which Andrew Hall had for a brief period succeeded him, was henceforth rendered impossible. About HackerNoon Book Series: We bring you the most important technical, scientific, and insightful public domain books. This book is part of the public domain. Garrett Putman Serviss (2005). The Moon Metal. Urbana, Illinois: Project Gutenberg. Retrieved October 2022 https://www.gutenberg.org/cache/epub/8199/pg8199-images.html This eBook is for the use of anyone anywhere at no cost and with almost no restrictions whatsoever. You may copy it, give it away or re-use it under the terms of the Project Gutenberg License included with this eBook or online at www.gutenberg.org , located at https://www.gutenberg.org/policy/license.html .

THE LOOTING OF THE MOON

A recent by Twitter reveals the company’s plans for a subscription based platform. They’re recruiting web engineers to work on a “subscription-based platform”. job listing The internal team working on this project, codenamed “Gryphon” will work closely with Twitter’s payment and twitter.com team to build a paid platform that “can be reused by other teams in future”. This will the first time Twitter’s doing anything like this. Twitter hasn’t still made a statement on what this platform will offer. In fact, we don’t even have a clear word on when this will release or if it will release. But it’s clear what’s forcing Twitter to look into this direction. And why Subscriptions are probably the best answer. Spoiler: this is not the first time Twitter has considered making a subscription service. But before we go into all that, let’s clear this out: Will you have to pay to use Twitter one day? tl;dr: NO. Never. You’ll be shown ads but Twitters will remain accessible to everyone regardless of financial status. Twitter believes putting a paywall doesn’t align with its core product values: being fast, broad and personalised, and generating discussions. “We believe that there’s a real importance that Twitter is accessible to everyone in the world no matter what their economic status is.” So, why does Twitter have to work on a subscription based platform? Currently, the advertising and data licensing pay the bills for. With ads accounting to nearly 84% of their revenue. But since 2020, the social network’s advertising revenue hasn’t been any good. COVID-19 has hit the advertising revenue bad. Despite a 24% surge in monthly active users, the revenue went up just 3%, the smallest increment in last 2 years. Bringing Twitter a loss of $7M. To worsen the issue, Twitter’s activist investors keep pushing CEO Jack Dorsey to bring revenue back to normal with operational changes. Why subscription is a good solution In these times, Twitter is desparately looking for new ways to get back to profitability. And subscription-based services are a good option. Because they’ve already considered such an option back in 2017, when their revenue was in a similar condition of loss. In 2017, Twitter ran a survey asking a number of users if they’d like to pay a certain amount to access an advanced version of Twitter’s TweetDeck tool. What’s TweetDeck? If you don’t know, is Twitter’s dashboard app that lets you manage and tweet from multiple twitter accounts and schedule tweets from a single column based interface. TweetDeck Although it’s currently free to use, mainly professionals like marketers, and brands use it. Most regular Twitter users don’t even know what TweetDeck is because Twitter never focused on marketing or updating it. But when in 2017, Twitter was searching for a profitable source of revenue, it found TweetDeck to be worth testing. And ran some surveys about it. What will premium TweetDeck offer? The survey also mentioned what features the premium version will have. Advanced analytics like audience insights, tool to monitor multiple timelines from multiple accounts. And no, you can’t still edit tweets. From: TechCrunch Okay, how much will it cost? No one has a sure word on the pricing. The survey showed different prices to different participants because folks at Twitter might be testing which pricing works best. Andrew Tavani who revealed some more information about this survey says the survey mentioned the price as $19.99 while TechCrunch’s Travis Bernard says it was $4.99 for him. So the price must be somewhere between $5 and $20. (Around the sum Twitter would’ve to pay you, if is successful). the data dividend project Twitter never revealed the results of that survey. But most probably, it wasn’t that good. Because Twitter never implemented the idea. Will it ever turn into a reality? I think yes. But not anytime this year. Probably next year. Because Twitter is recruiting engineers rather than surveying, this time. They’ve got it planned. It’s time for the execution. But maybe Twitter will make a subscription for regular users who want an ad-less and tracking-free environment instead of an “advanced TweetDeck”. Possibly, support for custom themes for Twitter interface. Anyways, here’s what a Twitter spokesperson told The Verge: “it’s only a job posting, not a product announcement.” It is similar to what back in 2017: Twitter said “We’re conducting this survey to assess the interest in a new, more enhanced version of Tweetdeck. We regularly conduct user research to gather feedback about people’s Twitter experience and to better inform our product investment decisions, and we’re exploring several ways to make Tweetdeck even more valuable for professionals.” How many will join? In 2017, when speculations of a subscription-based Twitter platform cooked up because of the survey, an analyst Mark Zgutowicz said the initial market for that service (advanced TweetDeck) will be somewhere around 10 million, which is ~3% of Twitters monthly active users. But if Twitter makes a subscription service for regular users and not just the pros, there’ll be many more getting the subscription happily. But yeah, it depends greatly on what the premium twitter will have to offer. Remembered the job listing mentioned in the beginning? Twitter changed that soon after it got media coverage. Here’s original listing: Source: The Verge

Twitter's Plans for Subscription Explained (*Not* About Last Night...)

by Retail illustration Sail Ho Studio Shopping and food delivery carts are a well-resourced topic but what if we take it a little further and create a shared cart for an office community or group of friends that will be useable, clear, and secure. This would take a load of at least one human in that group. Let me tell you how it goes sometimes in our office. Every now and then we need to make a group order of something or sign up for a corporate event with a choice of food. create a shared Google Doc and a clusterf**k of anonymous animals starts an onslaught. We If there was a service you could attach to any business and automate the complicated order and payment procedures, it could be useful. This is how you build such a service using Angular and Firebase Project source code on . GitHub Setting up a project 1. Add a GitHub repository, come up with a name, description, specify the type, the license, and the file. I called it FoodOrder: .gitignore 2. Then, clone the repository. For this, enter the following command in terminal: git clone git@github.com:denismaster/FoodOrder.git 3. Change the repository address on yours: 4. Then, navigate to the created catalog: cd FoodOrder 5. Install Angular CLI and create a new Angular application with it: npm install -g @angular/cli 6. Create a new project: ng FoodOrder --directory. --force new We are using the –directory option to create a project in the existing directory and the –force option to rewrite the README and . files. gitignore 7. Open the project in an editor. I use Visual Studio Code: 8. For design, we are using the Bootstrap 4.0 library. Install it with the following command: npm install bootstrap Developing the menu We’ll group the menu items into categories with different titles, prices, size in grams, and all sorts of additional details. Each category is defined by the title and the list of items. 1. Create a file with the contents . models.ts from here The Product class contains basic information about the product. describes the category of the product. The final menu is just a massive. ProductCategory ProductCategory[] 2. Add some items. Create a new service, let’s call it MenuService with a list of our products : from here In our case, the service returns the list of predefined objects but it can be changed at any given time, for example, for it to make a backend request. 3. Add components to display the menu, categories, and products. For this, use the following folder structure: The component displays the menu as a whole. This component is simple and is there just to show the complete list of items. Use the HTML code . And the Typescript . MenuComponent from here from here 4. Create the component. It is used to display the categories. Create a card with the category name and the list of products as a list of components. Use the HTML code for . And the Typescript . MenuCategoryComponent MenuCategoryItemComponent MenuCategoryComponent from here from here 5. Create the component. It is used to display the product itself, as well as the UI connected to it. In this component, we react to a click and display additional interface items for portion sizes. MenuCategoryItemComponent 6. You’ll need an additional class: UpdateOrderAction UpdateOrderAction {
   action: | name: ;
   category?: ;
   price: ;
} export interface "add" "remove" string string number This class describes the changes that happen to the order itself. Use the HTML code for . And the Typescript . MenuCategoryItemComponent from here from here 7. Collect the entire code. For that, create the component. At this stage, it will only display MenuComponent: HomeComponent <app-menu [menu]= >< "menu$ | async" /app-menu> And the following Typescript: ({
 selector: ,
 templateUrl: ,
}) HomeComponent OnInit {
 menu$: Observable<ProductCategory[]>; ( ) {

 }

 ngOnInit() { .menu$ = .menuService.getMenu().pipe(take( ));
 }
} @Component 'app-home' './home.component.html' export class implements constructor menuService: MenuService private this this 1 Here’s what the menu looks like at this point. Everything works fine but there is no total cost calculation and no sync. To implement those, we’ll need Firebase. Integrating Firebase As a backend, we’ll be using Google Firebase. We use Cloud FireStore to store the data. This is a NoSQL document-oriented database which uses collections and documents inside of them. The collections can be attached to different documents. Each table allows sending and changing data to all the subscribers in real time. This creates an instant update for all the clients. For this, use the menu we’ve developed. Install the AngularFire2 library . from here npm install firebase /fire --save @angular Add new models to models.ts to describe the order. OrderItem {
   id: ,
   name: ;
   category: ,
   price: } Order {
   dishes: OrderItem[]
} export interface string string string number export interface Inside the Firestore, we’ll be storing the order as an object with the dishes property as an massive. Inside this massive, we store the menu item name required to delete the order. OrderItem[] 1. Create a new service. We’ll be using it for the Firebase interaction. Creating an order: OrderService { Injectable } ; { Subject } ; { Router } ; { AngularFirestore } ; { v4 uuid } ; { Order } ; ({
   providedIn: }) OrderService { ( ) {
   }
   createOrder() { orderId = uuid();
       sessionStorage.setItem( , orderId) .afs.collection( ).doc<Order>(orderId).set({ dishes: [] })
           .then(_ => { .router.navigate([ ], { queryParams: { : orderId } });
           })
           .catch( {
               alert(err);
           })
   }
} import from '@angular/core' import from 'rxjs' import from '@angular/router' import from '@angular/fire/firestore' import as from 'uuid' import from './models' @Injectable 'root' export class constructor router: Router, afs: AngularFirestore, private private let 'current_order' this "orders" this '/' 'order' => err 2. To check the order code, use ActivatedRoute. We also save the existing order code value in the SessionStorage to easily recover it when reloading the page. { Component, OnInit } ; { ProductCategory } ; { Observable } ; { take } { MenuService } ; { ActivatedRoute } ; { OrderService } ; ({
   selector: ,
   templateUrl: ,
}) HomeComponent OnInit {
   menu$: Observable<ProductCategory[]>;
   orderId: ; ( ) { }

   ngOnInit() { order = .activatedRoute.snapshot.queryParams.order; (!order) { .orderService.createOrder(); .orderId = sessionStorage.getItem( );
       } { .orderId = order;
           sessionStorage.setItem( , order);
       } .menu$ = .menuService.getMenu().pipe(take( ));
   }
} import from '@angular/core' import from '../models' import from 'rxjs' import from 'rxjs/operators' import from '../menu/menu.service' import from '@angular/router' import from '../order.service' @Component 'app-home' './home.component.html' export class implements string constructor activatedRoute: ActivatedRoute, menuService: MenuService, orderService: OrderService private private private const this if this this 'current_order' else this 'current_order' this this 1 3. Create a special component to display the selected items (the cart). Let’s call it : OrderStatusComponent {{category}}: {{dish.name}} x {{dish.amount}} {{dish.name}} Total: {{ totalPrice}} ₽ < = > div class "card mb-3" < = > div class "card-body" < * = > div ngFor "let category of dishCategories" < > strong </ > strong < * = > span ngFor "let dish of categorizedDishes[category]" < * = > span ngIf "dish.amount>1" </ > span < * = > span ngIf "dish.amount==1" </ > span </ > span </ > div < > div < > strong </ > strong </ > div </ > div </ > div { Order } ; { Input, Component } ; ({
   selector: ,
   templateUrl: ,
}) OrderStatusComponent{ ()
   order: Order = ; dishes() { (! .order || ! .order.dishes) []; .order.dishes;
   } categorizedDishes() { .dishes.reduce( { (!prev[current.category]) {
               prev[current.category] = [{
                   name: current.name,
                   amount: }]
           } { productsInCategory: { name: , amount: }[] = prev[current.category]; currentDishIndex = productsInCategory.findIndex( p.name == current.name) (currentDishIndex !== ) {
                   productsInCategory[currentDishIndex].amount++;
               } {
                   productsInCategory.push({
                       name: current.name,
                       amount: });
               }

           } prev;
       }, {});
   } dishCategories() { .keys( .categorizedDishes);
   } totalPrice() { .dishes.reduce( { p + c.price
       }, )
   }

} import from '../models' import from '@angular/core' @Component 'app-order-status' './order-status.component.html' export class @Input null get if this this return return this get return this ( ) => prev, current if 1 else let string number let => p if -1 else 1 return get return Object this get return this ( ) => p, c return 0 4. Add the new method in : getOrder() OrderService getOrder(orderId: ): Observable<Order> { orderDoc = .afs.doc<Order>( ); orderDoc.valueChanges();
   } string const this `orders/ ` ${orderId} return With this method, we subscribe to the changes in the document in Firestore. This is how the data sync happens between different users who use the same order code. 5. Finally, add the method in , which will be updating the contents of the order in Firestore: updateOrder() OrderService updateOrder(orderId: , update: UpdateOrderAction) { order = .afs.doc<Order>( ).valueChanges().pipe(take( )).toPromise(); (update.action == ) { .afs.doc<Order>( ).update({
           dishes: < >firebase.firestore.FieldValue.arrayUnion({
             id: uuid(),
             name: update.name,
             category: update.category,
             price: update.price
           })
         })
       } { dishIds = order.dishes.filter( d.name==update.name).map( d.id); idToRemove = dishIds[ ]; (!idToRemove) ; .afs.doc<Order>( ).update({
           dishes: < >firebase.firestore.FieldValue.arrayRemove({
             id: idToRemove,
             name: update.name,
             category: update.category,
             price: update.price
           })
         })
       }
     } async string const await this `orders/ ` ${orderId} 1 if "add" this `orders/ ` ${orderId} any else const => d => d const 0 if return this `orders/ ` ${orderId} any Because of Firebase we also have a shareable cart between different users: 6. Add the ability to clear the cart with this code in : OrderService _clear$ = Subject< >(); clearOrder$() { ._clear$.asObservable();
   }

   clearOrder(orderId: ) { .afs.doc<Order>( ).update({
           dishes: []
       }) ._clear$.next();
   }
handleOrderClearing(){ ._clear$.next();
   } private new void get return this string this `orders/ ` ${orderId} this this 7. Modify : MenuCategoryItemComponent ( ) { .orderService.clearOrder$.subscribe( { .amount= ;
     sessionStorage.removeItem( )
   })
 } constructor orderService: OrderService private this => () this 0 ` - ` ${this.orderId} ${this.product.name} 8. Here’s how another user can clear the cart: .order$.pipe(filter( !!order)).subscribe( { (order.dishes && !order.dishes.length) { .orderService.handleOrderClearing();
           }
       }) this => order => order if this That’s basically it. Now the website has shared access and all it takes to start working is implement the order feature. Setting up CI/CD To set up CI/CD, use TravisCI. This product is really simple and sustainable, especially in the GitHub integration. For the setup, you’ll need the file in the root of the repository: .travis.yml This script assembles your Angular application and deploys the master branch in Firebase. For this, you’ll need the token which you receive with the following command: firebase login :ci An example build on TravisCI: written by Denis Obolensky & Moses Kim

Building Shared Access Shopping Cart With Angular & Firebase 

Apollo is the best solution for managing remote data with a client cache. But if you are already using Apollo (or another client cache like Relay), the question is: What should you do about the rest of your client state? React’s new context API (available in 16.3 or as a polyfill) has opened up new possibilities for dealing with app state. At , we’ve been trying to find that blissful state that combines the data from the server, component state, and the app state, which hasn’t always been smooth. OK GROW! App state is tiny I became interested in Redux after watching Dan Abramov’s seminal talk at ReactEurope. After I’d learned the basics of Redux, I began looking for information on “advanced Redux.” But that brought me face-to-face with the problem with Redux for users: Every tutorial I found turned out to be implementing a client cache. You would learn the three or so ways to do async with Redux and then implement those async actions to work with your Redux store. But Apollo’s client cache already does all of that. It has all of my loading and error states handled, it deals with optimistic updates, you name it. So what’s left to manage? Apollo The answer, as it turns out, is very little for most apps. Most of it should just live in components. React What about centralizing to Redux for better testability? I agree that this makes testing very easy, but I have two problems with it: The whole point of having a component system is for encapsulation. React allows you to put state into your components so that when you are working elsewhere, you don’t have to think about what’s happening in that component. As soon as you try to separate that functionality, you have keep two things in your head, the component and the state (which is now probably in a separate file, so you need more buffers open). Not only that, but there is also risk that somebody else (never you!) would be tempted to grab that state from a different component. It breaks encapsulation. I’ve heard of developers making their entire app out of functional components with all state coming from Redux. Hey, I had a “let’s use all functional components!” phase too. But having a global store bypasses the top-down data flow and makes your app harder to reason about. Also, that’s a lot more code! Removing state from components feels un-React-y. Some of this movement stems from the fact that testing components has been pretty awkward for a long time, but I think we can solve that using tools like (more on this in a future post), or possibly a new tool like . React Test Renderer Cosmos There are apps that will really benefit from Redux, so I’m not saying not to use it. But in my own work, I have not been able to justify the overhead once Apollo took over remote data synchronization and caching. What state is left to manage? If you put most of your state into components and have a client cache, what’s left? Almost nothing. In one app, I had only a single global state variable to manage. But I tried managing it directly with the old Context API, and that convinced me that app-wide state is still a problem worth solving! Here are some things I think legitimately belong in app-wide state: Top-down data propagation runs into a roadblock when you hit a routing boundary. Of course you’ll pass some params to dependent routes, but passing shared state is a recipe for disaster. Just use app state instead. State that needs to be shared between routes. Sure you could put it in your root component and pass it down, but why? As an aside, I think a case can be made to store current session information (e.g., is the user logged in) in state even though you can also do that with Apollo. State that is used all over the place. In the last app I worked on, we tried . The logic is compelling: Since you already have a nice library to query and update values in the database, and since most of your data will already be in that format, why not just store your app state the same way? Then you have one way to do things, and you can use the existing reactive query components to update UI elements regardless of whether the data is local or remote. Apollo Link State To be fair, Apollo Link State totally works, though I ran into some sharp edges on what was then a new addition to Apollo. The real problem is that the way you produce and consume local app data just doesn’t match the pattern of remote data. Queries for remote data tend to be specific to one part of your app and don’t repeat much. The queries are intentionally verbose to clarify the relationship between the client and server, and they may reside in their own files and may have options for optimistic updates, updating based on mutations, etc. They also make extensive use of loading/error state, the ability to select which fields you need, etc. But by definition, app data is ubiquitous and simple — usually key-value pairs, or sometimes objects that are needed in various combinations that are read and updated in multiple places in your app. You don’t need to select fields, deal with loading state, etc. Writing queries for these things is simply awkward and excessively verbose, and don’t forget that queries and mutations require separate code. Here’s an example: We had an app for ordering from restaurants. If you leave your table, it should clear incomplete orders and remove the table number you were sitting at. But you shouldn’t be able to do that if you have an unpaid tab (ticket). We had components with render props to compose in the state queries and mutations, and this was a piece of code that appeared in the app: <ClearOrder    render={clearOrder => (      <SetCurrentTable        render={setCurrentTable => (          <GetOrderStatus            render={({ ticketId }) => (              <HeaderButton                label="Leave Table"                disabled={!!ticketId}                onPress={() => {                  clearOrder();                  setCurrentTable({ qrCode: '' });                }}              />            )}          />        )}      />    )}  /> It’s almost enough to make you go back to higher order components! 😱 Actually, I think HOCs would be a good solution here, but composing individual operations is still pretty heavy. Enter Unstated Before we look at Unstated, I should say that you don’t need to use any other state library at all! The is quite nice and may be all you need, allowing you to keep state in a root component. That said, here’s that same component written with new Context API Unstated <Subscribe to={[Table, Order]}>  {(currentTable, order) => (    <HeaderButton      label="Leave Table"      disabled={!!order.state.ticketId}      onPress={() => {        order.clear();        currentTable.set({ qrCode: '' });      }}    />  )}</Subscribe> I find it much more readable, and there are fewer levels of indentation and fewer lines of code. It avoids the pyramid of doom in two ways: Get and set functionality can be shared in one state object, reducing imports. Order and table state could have been combined to one object if we preferred that. We are dealing with classes, so we can combine as many things as we like on that container. There’s a built-in way to subscribe to multiple state containers in one component – the prop takes an array of state objects. Subscribe to Finally, if we compare the code to perform , one of the actions, the difference becomes a little starker: clearOrder The GraphQL is simple enough but doesn’t tell us much: mutation clearOrder {  clearOrder @client} And the resolver ends up looking a lot like a Redux reducer. clearOrder: (_, __, { cache }) => {  const data = cache.readQuery({ query: GET_ORDER });  // make sure you mutate your object correctly  // or other state could be affected  data.items = [];  cache.writeQuery({ query: GET_ORDER, data });  return null; // if you forget to return null, you'll get errors}, The equivalent method in the Unstated class would be a one-liner: // make sure you bind your method if you might pass it// as a propclear = () => this.setState({ items: [] }); Ah, That feels better! Testing with unstated Because Unstated creates an object that is not a react component, you can test it without rendering the component just as you might with Redux: test('clear order', () => {  // instantiate and set up our state object for the test  const orderState = new OrderState();  orderState.setState({ items: ['hamburger'] });  orderState.clear();  expect(orderState.state.items).toEqual({ items: [] });}); Or you can test it in place by injecting it into a component tree with the prop: inject test('clear rendered Orders', () => {  // render an Orders component with the same orderState as above  // (here with react-test-renderer)  const tree = TestRenderer.create(    <Provider inject={[orderState]}>      <Orders />    </Provider>,  );  // make sure our order rendered (1 item)  expect(tree.root.findAllByType(OrderItem).length).toBe(1);  // "press" the leave-table button by calling its onPress, which will  // call our `clear()` method  const leaveTableButton = tree.root.findByProps({    testId: 'leave-table-button',  });  button.props.onPress();  expect(tree.root.findAllByType(OrderItem).length).toBe(0);}); Follow Your Bliss In fact, Unstated is so easy to use, it would be easy to use it for everything, but that’s not really the intent of the library. Use it judiciously, though, and it will fill in a small but very important hole in your state management. Using Unstated in my current project feels like I’ve finally arrived at a complete data solution, and I’m no longer wishing for something different. Originally published at www.okgrow.com .

State of Bliss: Handle Your State with React, Apollo, and Unstated

Table of contents Prerequisites Scope of this tutorial Installation of Dependencies Why use code generation tools? Freezed Code Generator Riverpod Code Generator Notifier Provider AsyncNotifierProvider Recap Conclusion References Maximizing the performance of your app is crucial for delivering a seamless user experience. As software developers, we constantly seek out tools that can enhance our coding experience while improving the efficiency and quality of our code. This beginner's guide focuses on utilizing the power of AsyncNotifierProvider and NotifierProvider from Riverpod, together with the Riverpod code generator, for efficient state management. By incorporating these tools, you can generate providers faster, simplify the process of passing ref property around, and streamline debugging. The guide includes simple examples that demonstrate how to use these providers in your project and leverage the benefits of the Freezed and Riverpod code generators. Flutter Prerequisites Basic knowledge of dart A basic understanding of flutter and state management. A code editor (Android Studio or recommended) VScode A mobile device or emulator to build on. You’ve read the first article in this series or have at least a basic knowledge of how Riverpod works 👇🏽 https://clouds.hashnode.dev/the-ultimate-guide-to-mastering-riverpod-for-flutter-beginners Scope of this tutorial In this tutorial, we will cover the following: Examples to show the implementation of the Notifier and AsyncNotifier Providers. How to use code generation tools like Freezed and Riverpod code generator. How to use to handle loading state AsyncValue How to use when working with an immutable class. copyWith Installation of Dependencies First, you will need to get to your and add the following packages pubspec.yaml dependencies:
  flutter_riverpod: ^2.1.3
  riverpod_annotation: ^1.1.1
  freezed_annotation: ^2.2.0
  freezed: ^2.3.2

dev_dependencies:
  build_runner:
  riverpod_generator: ^1.1.1 Then run flutter pub get You have successfully added the necessary dependencies to your project. Why use code generation tools? If you choose to work without code generation tools, your Riverpod providers will still be fully functional. However, Riverpod greatly recommends using code generation tools. Code generation is using a tool to generate code. In dart, once you add the code generation syntax and compile, your code is automatically generated. Doing this saves you the time and energy you would have used to write that code, especially when you are working on a big project and need to handle those tasks repeatedly. Code generation will help prevent those errors that can happen when doing the same task repeatedly. It makes debugging better and generally makes your life easier. Freezed Code Generator Freezed is a code generation package that helps you create data classes with Dart. With the use of Freezed you can generate models, unions and much more. Freezed allows you to focus on the definition of your data class, instead of writing long lines of code that may be error-prone. Riverpod Code Generator With the Riverpod code generation package, it is now easier to declare providers. You no longer need to write your providers by hand or wonder which particular provider will suit your use case. All you need to do is follow the syntax for defining your Riverpod code generator and annotate your code, then with you can generate all your providers. build_runner For instance, this is the code generation syntax for these different Riverpod providers For Providers: @riverpod
int foo(FooRef ref) => 0; For FutureProviders: @riverpod
Future<int> foo(FooRef ref) async {
  return 0;
} For StateProviders: @riverpod
class Foo extends _$Foo {
  @override
  int build() => 0;
} You can notice that there is a pattern for creating the providers. Once you put the correct syntax you can generate the providers just like that. Notifier Provider Riverpod 2.0 came with the addition of two new provider types, the NotifierProvider, and the AsyncNotifierProvider. Riverpod recommends you use the NotifierProvider instead of the ChangeNotifier and StateNotifier providers, so we are focusing on these two. The NotifierProvider is used to listen to and expose a Notifier. A Notifier exposes a state that can change over time. Let’s consider a simple example 👇🏽 We will build a random string generator with two buttons, one to generate a new string and the other to clear the entire list of strings. In this example, we will also be using the Riverpod code generator. First, using Riverpod annotation and the code syntax below, we will create a NotifierProvider. We will also add the functions for adding a random string and clearing the list of strings. We will add the name of the file to be generated by specifying with as seen in the code. part Note: The name of the file to be generated is the same as the name of the current file you are working on. When specifying it with you will need to add as that is how Riverpod-generated files are named. part .g.dart import 'package:riverpod_annotation/riverpod_annotation.dart';

part 'notifier_list_provider.g.dart';

@riverpod
class RandomStrNotifier extends _$RandomStrNotifier{
  @override
  List<String> build() {
    return [];
  }
//using Dart's spread operator we create a new copy of the list
  void addString(String randomStr){
    state = [...state, randomStr];
  }

  void removeStrings(){
    state = [];
  }
} From our code, we can see that the returns an empty List, then we added the two functions to add to the list and clear the list. NotifierProvider and AsyncNotifierProvider support immutable state, because our state is immutable, we can not say or . So we create a new copy of the list. is used for updating the UI state. RandomStrNotifier state.add state.remove state To run the code generator, run this command on the terminal: flutter pub run build_runner watch --delete-conflicting-outputs After it has successfully run, you can see your generated provider file, in your project tab, in your code editor. From the image above you can see what the generated file will look like. Note: If you get the error then run the command on your terminal. Could not find a file named "pubspec.yaml" in "C:\Users\… dart pub get Moving on, let’s add this provider and the functions to our UI Widget build(BuildContext context, ref) {
        // rebuid the widget when there is a change
    List<String> randomStrList = ref.watch(randomStrNotifierProvider);
    final random = Random();
    return Scaffold(
      appBar: AppBar(
        title: const Text("RiverPod Notifier Example App"),
        backgroundColor: Colors.brown,
      ),
      body: SingleChildScrollView(
        child: Column(
          children: [
            Column(
              children: [
                                //map to a list
                ...randomStrList.map((string) =>
                    Container(
                      alignment: Alignment.center,
                      margin: const EdgeInsets.only(bottom: 10,top: 5),
                      height: 30,
                        width: 300,
                        color: Colors.brown,
                        child: Text(string.toString(),
                          style: const TextStyle(
                            color: Colors.white
                          ),
                        )))
              ],
            ),
            Row(
              mainAxisAlignment: MainAxisAlignment.spaceAround,
              children: [
                ElevatedButton.icon(
                  icon: const Icon(Icons.add),
                  label: const Text('Generate'),
                  style: ElevatedButton.styleFrom(
                    backgroundColor: Colors.brown, // Background color
                  ),
                  onPressed: () {
                                    //add string to list function
                    ref.read(randomStrNotifierProvider.notifier).addString("This is the "
                        "random String ${5  + random.nextInt( 1000 + 1 - 5)}");
                  },
                ),

                ElevatedButton.icon(
                  icon: const Icon(Icons.clear),
                  label: const Text('Clear'),
                  style: ElevatedButton.styleFrom(
                    backgroundColor: Colors.brown, // Background color
                  ),
                  onPressed: () {
                                    //clear list function
                    ref.read(randomStrNotifierProvider.notifier).removeString();
                  },
                )
              ],
            )
          ],
        ),
      ),
    ); As you can see the Riverpod code generator, generated a matching randomStrNotifierProvider When you run the app it should look like this 👇🏽 AsyncNotifierProvider The AsyncNotifierProvider is used to listen to and expose an asyncNotifier. The AsyncNotifier is a notifier that is asynchronously initialized. Let’s dive into the example: We will be building a simple app that loads a list of products after a time duration of 3 seconds with a button to clear the list of products. First, we will use the Freezed code generator tool to create our product class. Then using the method we will create the product objects that will be going into our list. We will add the name of the file to be generated by specifying with as seen in the code. The name of the generated file is the current name of your file and This is how the freezed files are named. copyWith part .freezed.dart import 'package:freezed_annotation/freezed_annotation.dart';
//replace with part 'name_of_your_file.freezed.dart';
part 'async_notifier_list_provider.freezed.dart';

@freezed
class Product with _$Product{
  const Product._();
  const factory Product({
    String? name,
    String? description,

  }) = _Product;

}

  const Product _product1 =  Product(name: "Dart course for beginners",
                            description: "This is course will make you a dart star");
  final Product _product2 = _product1.copyWith(description: "This course will make you a pro");
  final Product _product3 = _product1.copyWith(name: "Ultimate Dart course for beginners");

final products = [
              _product1,
              _product2,
              _product3,
]; We can run this command on the terminal to generate the freezed file flutter pub run build_runner watch --delete-conflicting-outputs The image above shows how the Freezed generated file will look like. We used the method to create new objects of product that we added to the list. The method is used for returning a new object with the same properties as the original but with the values you have specified, it is used when working with immutable structures like Freezed. copyWith copyWith Now we will go ahead and add our Riverpod provider class, which will be fetching the list of products after 3 seconds. We will also add the function to clear the list of products as well. //replace with part 'name_of_your_file.g.dart';
part 'async_notifier_list_provider.g.dart';

@riverpod
class AsyncProducts extends _$AsyncProducts {
  Future<List<Product>> _fetchProducts() async {
    await Future.delayed(const Duration(seconds: 3));
    return products;
  }

  @override
  FutureOr<List<Product>> build() async {
    return _fetchProducts();
  }

  Future<void>clearProducts()async {
    state = const AsyncValue.loading();
    state = await AsyncValue.guard(() async{
      await Future.delayed(const Duration(seconds: 3));
      return [];
    });
  }

} The asyncNotifierProvider returns a future list of products. To modify the UI we will now create the function, using we can easily manage the loading, error state, and data state. clearProducts AsyncValue class Looking at the class, is used to transform a Future that can fail into something safe to read, it is recommended to use this instead of try and catch blocks. it will handle both the data and error states. AsyncValue AsyncValue.guard Next, run this command on the terminal to generate the necessary Freezed and Riverpod code flutter pub run build_runner watch --delete-conflicting-outputs Let’s add this provider and function to our UI Widget build(BuildContext context, WidgetRef ref) {
    final productProvider = ref.watch(asyncProductsProvider);
    return Scaffold(
        appBar: AppBar(
            title: const Text("AsyncNotifier"),
            actions: [
              IconButton(
                icon: const Icon(
                  Icons.clear,
                  color: Colors.white,
                ),
                onPressed: () {
                  ref.read(asyncProductsProvider.notifier).clearProducts();
                },
              )
            ]
        ),

      body: Container(
        child: productProvider.when(
          data: (products)=> ListView.builder(
              itemCount: products.length,
              itemBuilder: (context, index){
                return Padding(
                  padding: const EdgeInsets.only(left: 10,right: 10,top: 10),
                  child: Card(
                    color: Colors.blueAccent,
                    elevation: 3,
                    child: ListTile(
                      title: Text("${products[index].name}",style: const TextStyle(
                          color: Colors.white,  fontSize: 15)),
                      subtitle: Text("${products[index].description}",style: const TextStyle(
                          color: Colors.white,  fontSize: 15)),
                    ),
                  ),
                );
              }),
          error: (err, stack) => Text("Error: $err",style: const TextStyle(
              color: Colors.white,  fontSize: 15)),
          loading: ()=> const Center(child: CircularProgressIndicator(color: Colors.blue,)),
        ),
      ),
    );
  } Here we can see that by calling we can access our provider, then we add the clear product function to the by calling . Now we can handle the different states of the response, using ref.watch onPressed ref.read productProvider.when When you run the app it should look like this 👇🏽 Recap We have come to the end of this tutorial. Here we have learned that: The NotifierProvider listens to and exposes a notifier, when there is a change in state, it automatically updates the UI. AsyncNotifierProvider is used to listen and expose a notifier that is asynchronously initialized. Using code generation tools like Freezed and Riverpod code generators, we can easily generate data and provider classes with very little code. The copyWith method used to create a new object but with values you specified, when working with immutable classes. Finally, the AsyncValue class is used to efficiently handle data, loading, and error states. Conclusion Congratulations, you have successfully learned how to use Riverpod’s newest providers, NotifierProvider and AsyncNotifierProvider to manage state, how to use code generation tools to generate code, and how to use copyWith method and AsyncValue class. If you enjoyed this article, do well to leave a reaction and follow me for more content. If you have any questions or spot any errors, please do leave feedback. References Riverpod Docs Also published here.

Optimizing Flutter Performance: A Guide to (Async)NotifierProvider, Freezed, and Riverpod Code Gen

JavaScript is a programming language that allows you to implement complex features on web pages and, to cut a long story short, you have already known a lot about JS since it is the most popular programming language in 2019 (it’s not our opinion, all figures we got from from Stackoverflow). If you don’t hear of this survey you should take a look, while we continue our introduction. Developer Survey 2019 Since JavaScript is the basis of any web application, we are not going to discuss JS benefits or a list of JS possibilities. Instead, we will show you some typical mistakes that almost every JS programmer has made during his career. According to the same Stackoverflow survey, 41% of programmers that took part in the survey have less than five years of professional coding experience. This article is mostly for those developers. New developers (0-2 years) may find examples from the article useful because it’s a bad code you can learn from. More experienced developers (3 + years) may get a smile by recognizing the mistakes you have made in the past. Anyway spending some time reading this article gives you either knowledge or fun. Enjoy reading! The list of mistakes: Do you remember the difference between “=“, “==“ and “===“? Forgetting about the scope of variables. Misunderstanding the difference between “let”, “const” and “var”. Incorrect references to instance methods. Difficulties of using this. Do you remember the difference between “=“, “==“ and “===“? Odds are you first encountered the problem with code like this: x = ; (x = ) { 
  alert( ); 
} {
  alert( );
} var 1 if 7 "Hello" else "Nope" And you get “Hello”! Why? The answer is very simple: you don’t understand the difference between the 3 operators mentioned above. It’s not a complicated mistake, and once you learn it you will not likely forget it. Since this mistake is very simple, you can overlook it when it comes to conditions of jumping out of a loop. Let’s get this thing over with and go further: “=” is the equal operator, so it’s used for assignment. In our example, we assign seven to “x” in the condition and get words of welcome “Hello”. The correct code looks like this: x = ; (x == ) {
  alert( );
} {
  alert( );
} var 1 if 7 "Hello" else "Nope" We get “Nope”. “==” is the loose equality comparison operator. Why loose? Because it allows converting values from one type to another to compare them. Even if we assign a string value “7” to x, and compare it with number value “7” the code returns to us “Hello”. However, the code below returns “Nope”: Why? Because “===” is the strict equality comparison operator. If this operator returns “true” it means that our values are identical both in value and in type. There is an analog for “===” – the method Object.is. It has some differences in the processing of -0, +0 and NaN values, but some of you know what these differences are, while others can turn to . And in general, it’s a good practice: JavaScript Guide If you have any doubts about JS methods or features, you can always google it. Forgetting about the scope of variables Another quite simple mistake: arr = [ , , , , , , ]; j; (j= ;  j < arr.length; j++) { .log (arr[j]);
} .log ( j ); let 1 2 3 4 5 6 7 var for 0 console // …some long code console // we get the number “7” And it’s easy to forget that our variable changes its value after the loop. This mistake exists not only in the JS community but in general. In some languages, you define a variable only within a loop, and it’s destroyed once the loop ends, but not in JavaScript. And the opposite situation, when you try to get access to a variable that was defined within their local scope (it refers to Function scope). Example: { me = ;
} .log(me); ( ) function myFunction var "You can't touch me!" console “me” is not defined, sorry, you can contact your lawyer or just remember the scope of variables in JavaScript. The correct code is: me; {
  me = ;
} .log(me + ‘I Can, sorry’); var ( ) function myFunction "You can't touch me!" console Another example since JS update in 2015, and the keyword came to JS to declare variables (ECMAScript 6) is: let arr = [ , , , , , , ]; ( j = ; j < arr.length; j++) { .log(arr[j]); } .log(j) let 1 2 3 4 5 6 7 for let 0 console // the output: 1, 2, 3, 4, 5, 6, 7 console // j = 0. The keyword let didn’t change the variable “j” compared to the first example. And this question is the topic of our next abstract. Misunderstanding the difference between “let”, “const” and “var” It’s closely related to the previous problem, but since almost everybody googled the difference between , and we separate this question. Let’s first look at the code below: var const let .log(x); x = ; .log(x); console // undefined var 5 console // the output is 5 The code is logical as the output, no questions. Another example: .log(x); x = ; .log(x); console // Error: cannot access “x” before the initialization let 5 console The reason is that is function scoped and is block scoped. When you declare a variable with keyword, they are moved to the beginning of the block. This may lead to a reference error when you try to access the variable before the initialization. var let let It’s called “temporary dead zone”, if you want to know more information about it, you can visit an official web site for JS developers . Mozilla JavaScript Guide But we move on with our next participant and show an example to describe everything: a = ; b = ; c = ; (a === ) { a = ; b = ; c = ; .log(a); .log(b); .log(c); } .log(a); .log(b); .log(c); let 5 var 10 const 11 if 5 let 4 // The scope is inside the if-block var 1 // The scope is global const 15 // The scope is inside the if-block console // 4, console // 1 console // 15 console // 5, the value changes to the initial console // 1, the value from if-block saves console // 11, the value changes to the initial And the last code for this chapter: a = ; b = ; c = ; c = ; 10 // it’s OK, the value of a is changed to 10 20 // it’s OK, the value of b is changed to 20 7 // SyntaxError: Identifier "c" has already beed declared const 15 // The same error What happened? In “if block” we declared “a” and “c” variables in if-block and changed the value of a global variable “b”. Outside the block “a” and “C” returned to its initial values. After that, we tried to change the values of all variables: and allow us to do that, while returned an error. The reason is that the declares a read-only reference to a value within a certain scope (it may be local or global). That’s why we managed to declare the new value of the “C” variable in if-block but failed to change the value outside of it. let var const const Incorrect references to instance methods Let’s create a new object and use the prototype property of a function to add “ ” method. Then create an instance “ ” of our object (the code below): whoAmI obj MyObject = {}
MyObject.prototype.whoAmI = { .log( === ? : ); 
} obj = MyObject(); var ( ) function ( ) function console this window "window" "MyObj" var new The preparatory phase ended, let’s start to make our life simpler: since we need to get access to a recently established method and we want to make it simple, so let’s create a reference to it and check if it works properly. obj.whoAmI(); anotherMethod = obj.whoAmI;
anotherMethod(); // MyObj var // window And we get the output “window” instead of expected “MyObj”. Why? Well, when we create a reference = , method has been defined in the global scope. A global scope is a window object in a browser, so the keyword becomes equal to the window, not the instance of . If we want to make a correct reference to an instance method, then we need to call this method from the object itself or make a reference to the object, but not just to the method of the object. var anotherMethod obj.whoAmI whoAmI this MyObject The right reference will look like this: obj = MyObject(); anotherObj = obj;
anotherObj.whoAmI() var new var // MyObj or obj.link = obj.whoAmI
obj.link(); // MyObj And we get the equal result finally. Difficulties of using this JavaScript has become quite a complicated language. is a keyword in JavaScript the value of which is evaluated during the run-time, depending on the context. This { myObject = { : , : {
        alert(objProperty);
        }
     }
  myObject.objMethod();
} 
myFunction(); ( ) function myFunction var objProperty "some text" objMethod ( ) function And we get . Functions defined on a JavaScript object accessing properties on that JavaScript object and failing to use reference identifier. The correct code looks like this: ReferenceError: objProperty is not defined this { myObject = { : , : {
        alert( .objProperty);
        }
     }
  myObject.objMethod();
}
myFunction(); ( ) function myFunction var objProperty "some text" objMethod ( ) function this The idea is simple: when is called, becomes during the call of . When we define an object and want to access its properties and methods, we need to access the object itself first. (sounds logical) But there are also reverse situations when is used incorrectly. myObject.objMethod this myObject objMethod this Game.prototype.restart = { .clearLocalStorage(); .timer = setTimeout( { .clearBoard(); 
  }, );
} ( ) function this this ( ) function this 0 It returns to us another error: undefined is not a function. The point is that in line is unnecessary here because when you invoke you work with , so you invoke the window object in the browser. The object window doesn’t have a method. The correct form will look like this: this this.clearBoard() setTimeout() window.setTimeout() clearBoard() Game.prototype.restart = { self = ; .clearLocalStorage(); .timer = setTimeout( {
    self.clearBoard(); }, );
} ( ) function var this this this ( ) function // this = window 0 And an example that has existed since EcmaScript 2015 was released: Game.prototype.restart = { .clearLocalStorage(); .timer = setTimeout( { .clearBoard(); }, );
} ( ) function this this => () this // this = Game 0 That also became possible after ECMAScript 6. When we use an arrow function, we stay in the scope of the previous function without creating a new local scope. Memory leaks, what lays beyond it Let’s start with a code: {
  me = ;
} ( ) function myFunction "You can't touch me!" It’s an altered example from the second chapter of this article, can you see the difference? If yes, it’s great – you are aware of declaring unnecessary global variables and stay careful when it comes to the speed of your code. The problem with this code is that when we call the function , we create an unnecessary global variable that is lurking in the background until the code doesn’t terminate. The global variable is created because we assign a value to a variable that hasn’t been declared before. myFunction Although the variables don’t take a lot of memory, too much data stored as cash slows the page download speed and negatively affects the speed of your browser in general. There are several possible solutions: Use local variables: { me = ;
} ( ) function myFunction var "You can't touch me!" Use “use strict” Directive that doesn’t allow you to invoke undeclared variable: {
  “use strict”;
  me = ; } ( ) function myFunction "You can't touch me!" //me is not defined Memory leaks occur when an app stores the unnecessary data that the garbage collector doesn’t clean in its run. Another event that leads to memory leaks is when an app consumes memory for a specific task: once the task is completed, memory is released, but sometimes it is not. So the app keeps the memory for no reason (since the task is done). Let’s consider another code: trigger = .getElementById( ); elem = .getElementById( );
trigger.addEventListener( , {
  elem.remove();
}); var document "trigger" var document 'elementToDelete' "click" ( ) function When we execute the code, is removed from the DOM. But we still have the reference to it within the listener, and at this point the memory leak happens because allocated memory for the object is still used. elementToDelete The solution is here: trigger = .getElementById( );
trigger.addEventListener( , { elem = .getElementById( );
  elem.remove();
}); var document "trigger" "click" ( ) function var document 'elementToDelete' Here is declared inside the listener. Thus when we delete it, the path for the object is cut off and the memory will be released. elem

Top Mistakes JavaScript Developers Make

My three takeaways from URBAN-X’s event: Hyperlegible Cities The URBAN-X panel on “Hyperlegible Cities” was thought-provoking. , , , , , all participated in a lively discussion moderated by . Bianca Wylie Elizabeth Bowie Christoforetti Tara Pham Paul Salama Miriam Roure Sara Trigoboff Greg Lindsay The key questions of the night probed (1) the consequences of being “too” legible and (2) some solutions to mitigate problems. I interpreted “legibility” as the rules that govern our cities. The conversation sparked three takeaways that I delve into below: Benefits — Rules, obviously, can result in efficiency. Costs — Our rules and meta-rules can result in inequality, even if those rules are governed formally by participatory democracy. Solutions — I review an incomprehensive list of strategies for how we might rewrite the rules: trust companies, empower companies to be ethical, empower governments to create better meta-rules. 1) Our rules can result in efficiency. Rules have some obvious benefits. One big one is standardization, which helps societies create stable expectations about the present and the . When we know how things should be built and the consequences of violating these rules, we can act more efficiently. future An obvious example are local zoning laws and building codes. They’ve created baseline standards to promote building safety, public health, responsible infrastructure use, and (socially-constructed) standards of neighborhood quality and image. following a strict set of zoning laws Classic suburb 2) Our rules and meta-rules can result in inequality, even if those rules are governed by participatory democracy. But it’s hard to write rules — and the meta-rules to influence those rules — that are fair for everyone. Even in participatory democracies, those who have more resources are able to stack the rules and meta-rules of the game in their own favor. As Miriam (or Sara?) mentioned, we need to think about who profits from the rules. Take zoning laws again. Housing is extremely expensive in some of our highest-growth cities, like SF and NYC. A major cause are rules that exclude many housing designs: we can’t build houses on smaller lots or without garages. Bigger sizes mean fewer and more expensive units, excluding people who have more moderate means. Unsurprisingly, urban scholars often name these rules “ ” laws. exclusionary zoning Laws encourage McMansions It makes sense why people don’t want density. Increased traffic, for instance, can harm local quality of life. Many cities lack good public transit systems to help people get around. Yet our meta-rules hamper the generation of new possibilities. Many planning meetings happen after work or during weekday afternoons without food or childcare, and require extensive time commitment. Those who have the resources (time, money, and network) are more likely to have influence than less-resourced actors, such as renters, people of moderate means, or minorities. Participating groups may have homogeneous life experiences. Without diversity, new ideas to balance density and quality of life will be harder to generate. Example Community Planning meeting And even when less-resourced actors do participate, conversations are understandably tense, not collaborative, as discussions are framed as binary choices to approve or reject new proposals. I review an incomprehensive list of strategies that include: trust companies, empower companies to be ethical, and empower governments to create better meta-rules. 3) Given the problems above, there’s an argument for rewriting the rules. 1. Trust companies Most of the panel opposed this. Public companies, Tara Pham pointed out, are legally bound to their shareholders, not to the broader public. Bianca Wylie noted that many companies, like Uber, actually violated rules and process when launching their services and in the name of growth. Yet, as Paul Salam discussed, these companies often have the resources and technical capacity to start ambitious experiments, such as Google’s Sidewalk Toronto. While they can partner, Bianca argues, they should not be rule-makers. It’s the private sector’s responsibility, in fact, to recognize those boundaries publicly and call for democratic processes on rules of import, such as data and AI . governance 2. Empower companies to be ethical Technical tools are emerging to help companies do better. Regtech, for instance, helps companies reduce the cost of compliance — rather than find ways to shirk their obligations. , for instance, helps companies easily become ethical stewards of their customer’s data. Ethical data management software Legal tools can also start to rewire companies for social impact. protect the vision of mission-oriented founders. In public benefit corporations, social benefit is embedded in a company’s charter, creating the legal obligation to balance shareholder value against social impact. Public benefit corporations 3. Empower government to design better meta-rules When we design meta-rules (again, rules about our process to create rules), we need to think about what our goals are for this participatory process. Is it more diverse, inclusive participation? Is it more creative ideas? Is it to make higher-quality, evidence-based decisions? Is it, sadly, mere ? When we identify goals, we can design and test better meta-rules. CYA Designing better meta-rules also means we, as Bianca Wylie urges, don’t give up on the public sector. An entire industry of startups — such as govtech, civictech, and suptech startups — has this as its mission. Upgrading the infrastructure for more diverse, inclusive, and data-driven urban governance is one of the most promising we can do to create better cities. 1. Meta-rules that spur new actors to grow and participate We should also, perhaps, be wary of over-regulation (i.e., being hyperlegible?). , for instance, can hurt small businesses and other small actors without large compliance departments. These rules, as a result, need to be crafted responsibly. Regulation in the data governance realm Take the housing space. As discussed above, extensive height and minimum lot size restrictions restrict density and innovation. By relaxing these rules, new housing actors are emerging, such as micro-living developers, co-living operators, and tiny home owners that I survey in , , and . The Multifamily Executive Shelterforce Hackernoon 2. Meta-rules that favor social responsibility Yet relaxing rules and providing incentives can reek of corruption. Many housing incentives — such as free land grants — favor large, shareholder maximizing corporations. To the public, this looks like crony capitalism and diminishes trust in urban governance, even though the government truly believes private actors can build housing more efficiently. But if private actors can be more efficient, as Chris Chou and I ask in the , why not instead favor those that embrace social good? , like Baugruppen, and come to mind. Columbia Public Policy Review Community-driven development cooperatives public benefit corporations To build capacity of these actors, policy should provide technical assistance and promote the use of proven cost-reduction techniques, many of which I feature in . The Multifamily Executive 3. Meta-rules that promote evidence-based experimentation Only once policies are shown to be effective, governments can decide to scale them. In a forthcoming article, I discuss that through pilots, governments can engage in experimental pilots before scaling new policies. These efforts can suss out harms early and iterate on policies after examining real data. The startups that benefit from such pilots should promise to hold their data in a public data trust, similar to . evidence-generating Sidewalk Toronto’s recent proposal Startups can also help governments better understand problems and track the impact of their policies. Using sensors, , for instance, can track data on how things move in streets and open space. gathers information to help governments understand the impact of poverty-reduction programs. The open data movement, more generally, is empowering citizens to make sense of public data and build solutions. analyzes citizen’s qualitative feedback about city initiatives on social media platforms and other sources to modify policy. Numina Outline India Zencity Using this data, startups can also help government experiment with new types of policies that were previously impossible to execute. Paul Salam’s , for instance, can help governments create usage-based policies of roads to help private companies and other actors that use public infrastructure more pay more for its repair and construction. ClearRoad 4. Meta-rules that promote inclusive participation In the realm of national elections, other countries have experimented with mandatory voting, voting holidays, electronic voting, publicly-funded campaigns, participatory budgeting, (a point Tara also raised), and proportional voting systems. gerrymandering reform The efficacy of these ideas are unclear. But they nonetheless address key problems that hamper diverse, inclusive participation in national elections. For instance, voting holidays and electronic voting reduce the costs to participation. We need draw from these areas for urban governance. Tools are emerging to help people participate in public processes better. ’s and ’s platforms engage those that do not have the resources to participate in time-consuming development processes. helped engage NYC residents in the budgeting process using an online platform to collect ideas and vote on them. CoUrbanize Neighborland Democracy21 helps developers and citizens obtain permits more easily. They turn complex paper-based permitting processes into a streamlined, digital workflow. Their software has increased the speed with which permits are submitted and processed, helping mitigate the pain in one critical step of the development process. Camino.ai With , everyday homeowners type in their zipcode, answer a few questions, and obtain a code-compliant ADU to place in their backyard. With such efforts, small-scale housing development has become a service. Cover 5. Capacity-building to keep promoting process innovations More generally, governments can prioritize efforts to enhance their own capacities to create better rules. Al Gore’s in the early 90’s is one precedent. National Partnership for Reinventing Government Such initiatives were not easy. They had to overcome capacity issues — governments pay less and have a harder time attracting technical and other scarce talent that would get paid much more elsewhere. They also had to overcome slow-moving processes to navigate red tape, which hampers innovation. Transparent and fair government procurement and request for proposal processes are foundational to ensure the highest-quality solutions are used. can and has helped. Efforts like , , and are addressing the procurement problem. helps governments such as Las Vegas and Pittsburgh assess their vendors better. Technology CoProcure Startups in Residence Atlas’ procurement toolkit UrbanLeap In sum Recently, the revamping of meta-rules happened in the data regulation world. The General Data Protection Regulation (“GDPR”) rewired some meta-rules about who could participate in data management. Up to the passage of this legislation, most companies assumed customer data was their to keep and control, with broad consent. In fact, most people thought data protection was dead. But GDPR — along with voracious critiques of Facebook and Sidewalk Toronto — have sparked global conversations about including individual people who may have more say in the management of their data and to challenge decisions made by algorithms. As data collection and automated decision-making becomes more prevalent in urban governance, so too will urbanists grapple with data and AI governance issues. Who gets to participate and how do we keep algorithmic decisions accountable? Some tools are emerging, such as the for cities and standards to evaluate how cities are using data and AI, such as Bloomberg’s . Ethics and Algorithms toolkit What Works Cities I’m excited about how people are going to tackle these governance challenges. URBAN-X’s panelists did a great job illuminating them. Please share other promising strategies to do so. ☞ Agree or disagree? Add me on LinkedIn with a note here .

Ignoring the Future of Urban Governance Will Kill Vibrant Cities

Many developers aspire to be in a CTO-role someday, but what does it actually take to be a CTO? It of course depends on the size and stage of a company and other factors like how the technology team is structured. In this article we dive into some common characteristics of the role and hear directly from CTO’s about what their jobs consist of. CTO Job Description While it’s true that a Chief Technology Officer may have to wear many different hats in their time (particularly at a startup), the role does have an official definition with which we can work from Academic Publishers as follows: Taylor and Francis define a Chief Technology Officer’s role “An executive-level position in a company or other entity whose occupation is focused on scientific and technological issues within an organization.” Now, while that’s a digestible definition, let’s delve deeper into the true job description of a CTO. The ‘Chief’ Part First things first, the title of ‘Chief’ holds great power — and you don’t need me to tell you that with great power, comes great responsibility. Here’s what what a CTO needs to do to put the Chief in Chief Technology Officer. The strategy and design that a CTO develops with his team often becomes little more than a huge to-do list. A good CTO will have the product and project management skills to attack that list. Managing Roadmaps, Tasks & Deadlines: A competent CTO rises to challenges and gets his or her hands dirty, proving that they can contribute as well as dish out orders. Speaking of which… Getting Your Hands Dirty: As mentioned in the previous point, a CTO should be working on the frontlines — however, it still holds true that the only way all of that listed work will get done is if the people beneath the CTO pull their weight. To make sure that happens, a CTO needs to know when to hand something off to a colleague. Delegation: On the topic of delegation in particular, we spoke to CTO Ruslan Sukhar, who gave us his insights: Convertful “Delegation [is definitely part of the job], and it’s a personal challenge for me. For example, I can spend a whole weekend just making sure some specific UX is seamless, although that’s not the most valuable thing I could spend my time on.” The ‘Technology’ Part As you might have guessed, a CTO’s role revolves heavily around technology. Here’s how. Contemporary companies work in a digitally volatile space, and it’s the CTO’s job to ensure that the company has the best technology for the job(s) at hand. That includes recommending the right CMS to handle content distribution across existing and emerging channels. Technology Strategy: A CTO needs to have a voice in the company strategy — especially since most (if not all) business strategies today rely heavily upon technology to exist, reach consumers and scale. More specifically, it’s upon the CTO to think up ways for his CEO and stakeholders to fulfil their goals. If they can do that well, the CTO ends up at the forefront of innovative projects. Business Strategy: Finally, the CTO is also a public face of technology for the company. They need to tend to the internal wellbeing of the company’s tech and be the driving force behind the brand’s technical prowess and insight. The CTO needs to represent that prowess in public appearances, in front of the press, and at conferences. Evangelism: Once again we spoke to Convertful’s CTO Ruslan Sukhar about this side of the story: “I believe that CTO should be involved in business development in a technical way. It means CTO should always think not only about how to develop a certain product but also about how certain technologies can gain additional profits, and/or reduce costs.” A Day in the Life of a CTO To get better acquainted with the business life of a Chief Technology Officer, we have looked to , the author of The Lean and an ex-CTO of over four years: the words of Eric Ries Startup “The CTO’s primary job is to make sure the company’s strategy serves its business strategy,” He said. technology Reis went on to highlight that a good CTO should also give their company options when their business strategy demands it: “A mark of a good CTO is that they never say “that’s impossible” or “we’d never do that.” Instead, they find options and can communicate them to everyone in the company. If the CEO wants to completely change the product in order to serve a new customer segment, you need someone in the room who can digest the needs of the new (proposed) business, and lay out the costs of each possible approach.” Another CTO, Karl Schulmeisters of ClearRoadmap, also a startup Chief Technology Officer has to wear: shone light on the many different hats “As a startup CTO I wore the following hats; Enterprise architect, SCRUM master, developer, lead quality assurer, social media manager, blogger, [and so forth].” And Schulmeisters doesn’t seem to be alone in having to swap hats on a daily basis. John Petrone, CTO at LaunchPad Central, concurred: “I’d say that a startup CTO needs to be something of a jack of all trades when it comes to technology issues. In the last week at my current early stage startup I’ve; phone screened and interviewed engineering candidates, researched a variety of technology directions, set up a new laptop for someone, checked some code, [and more].” The Complex Role of a CTO The role of a Chief Technology Officer is complex, and every CTO will have his or her own unique traits to bring to the table. But one thing is for sure, a CTO needs to have his or her finger on the technological pulse — always aware of new trends and the technologies behind them. A great CTO should be ready to delegate, while also being comfortable enough to work on the frontline, coding alongside their fellow developers. Furthermore, they will be required to be even more flexible if they’re working in a startup. If you’re still looking for more insights into the life of a Chief Technology Officer, check out our discussions with selected CTOs revolving around the topics of and . writing good code managing deadlines at a CTO How would you describe yourself as a CTO? Are you a great architect, evangelist, interface designer, debugger, or a helpful Jack of all trades? Let us know in the comments section below! For more content like this, follow ButterCMS on Twitter and subscribe to our blog . Originally published at buttercms.com

Stories, News & Mentions about CLEARWORD

Clearword’s Stories on HackerNoon