Heat Watch is a fast-paced, customer-focused New York City / Boston based energy tech startup that controls and runs the heating systems in nearly 1800 + buildings throughout the Northeast

Heat Watch

heatwatch

Getting Personal with Data Frustrated with overflowing waiting rooms, appointments running behind schedule and impersonal and often rushed doctor appointments, I found myself asking is there a better approach to managing my healthcare needs? And earlier this year I found an answer that is working for me, concierge medicine. is a pioneering model of medical practice that puts the patient at the heart of the healthcare experience; under a concierge-style practice, patients pay a monthly or annual subscription fee and in return receive personalized, attentive health care through one appointed, dedicated physician who is familiar with their medical history. Concierge medicine Concierge medicine is geared to the personalized convenience for patients and gaining traction as we as patients look for a way to bypass the red tape of insurance companies, shorten our wait times and other inconveniences that may accompany a visit to a traditional doctor. On the providers’ side, doctors have joined concierge groups to avoid the long hours, endless paperwork and the high overhead costs associated with an understaffed and often underpaid practice. Longer appointment times, same-day visits and round-the-clock access to their doctor whether in person, phone, text or Skype are part of the concierge-style practice. The combination of technology, data, information transparency, and consumer frustration has set the stage for an evolution in the healthcare model and puts the patient first and at the center of the medical care delivery experience. It’s Personal Health care is personal. And with the recent explosion of genomic data available, the concept of “personalization” is taking on a new meaning, charting a new course to improve one’s health. The describes precision medicine as “an emerging approach for disease treatment and prevention that takes into account individual variability in genes, environment, and lifestyle for each person.” These unique data points have given the medical industry incredible amounts of information with the ability to analyze the data and offer meaningful insights into one’s health. Our DNA plays a significant role in the risk of disease and severity, and which treatment we will respond to best with the least amount of side effects. In a recent , Eric Dishman shared how the kidney cancer he’d been diagnosed with in college had caught up to him two decades later. His kidneys had failed, and the chemo drug that kept him alive was incompatible with dialysis. A friend happened to work for a DNA sequencing company and offered to analyze the genome of Dishman’s cancer cells. Days before he was to start dialy­sis, his doctors called. Dishman’s kidney cancer mutations looked like they actually belonged to a form of pancreatic cancer. He switched to a drug designed for tumors in a totally different organ. It worked. Dishman is finally cancer-free after more than 20 years — and, following a successful kidney transplant, he now heads the Precision Medicine Initiative Cohort Program at the National Institutes of Health. Leveraging the insights this data provides is where the next phase of personalized medicine is heading. National Institutes of Health (NIH) article “Welcome to you.” The largest consumer genetic testing company, , says it now has more than two million genotyped customers. The FDA allows 23andMe to market tests that assess genetic risks for ten diseases or conditions including Parkinson’s disease, Celiac disease, and Late-onset Alzheimer’s disease. This past holiday season, The 23andMe DNA Test kit was one of s on both Black Friday and Cyber Monday. 23andMe Amazon’s five best-selling item With the combination of data and technology, there is evidence that the digitization of healthcare is already saving lives with the possibility to save thousands. A recent example is how the Scott Killian’s Apple Watch woke him up around 1 am with an alert from a third-party app called HeartWatch saying his resting heart rate was elevated while sleeping. His Apple Watch charted his heart rate at around 121 beats per minute in the middle of the night while data previously captured showed his average resting heart rate at about 49 beats per minute. The data also showed that this was the first time his resting heart rate had reached this level since he began wearing Apple Watch, so he decided to go to the emergency room as a precaution. The hospital took a blood test and discovered an elevated enzyme that signals a heart attack has occurred or is occurring. Further testing revealed four blocked arteries which required the insertion of four stents (inflated titanium carbon fiber sleeves) to correct. Apple Watch saved Scott Killian’s life. 90% of the data on the internet has been created since 2016 According to an study, 90% of the data on the internet has been created since 2016. This is not surprising with an estimated in the first quarter of 2017! IBM Marketing Cloud 3.8 billion internet users The internet continues to grow quickly while generating massive amounts of data. In just : one internet minute in 2017 120 New created LinkedIn accounts 3.5 million Google searches 342,000 downloaded Apps 16 million sent text messages 2 million minutes of calls done by Skype users 800,000+ files on DropBox uploaded Amazon processed in sales every day in 2017 $373 MILLION . There were approximately global mobile Internet users as at August 2017. There are more mobile Internet users than desktop Internet users 3.5 billion The e-commerce industry is responsible for about $ in annual sales 2 trillion Mobile commerce revenue was $170 billion in 2016, and it is estimated to be by 2019 $694 billion Mobile traffic is responsible for of internet traffic 52% By 2020, 75% of cars will come with built-in IoT connectivity Wholesale Used Vehicle Auctions Today, with the power of data and analytics combined with digitization, there is tremendous opportunity to create strategies that will reduce depreciation and holding cost(s) while maximizing value for consignors. These insights help consignors get a better understanding of how their portfolio is performing down to the VIN-specific details and what they should do with it — extend it, pull it forward, move it somewhere — so they can take advantage of the best market opportunities. A digital wholesale vehicle auction in conjunction with a physical auction and integrated with data and Analytics creates a seamless integrated auction experience that helps buyers and sellers make informed decisions in vehicle remarketing.

Getting Personal with Data

Interactions are always important in data visualization. The Flutter charting library has a well-designed interaction system for various interactive charts. Graphic This system is built on several concepts, and when you leant these concepts you will find it's quite easy and flexible to handle interactions in . Some of the concepts are novel, but intuitive and easy to understand. Graphic This article will introduce these concepts to help you build interactive charts in Flutter with . Graphic Gesture As a touch-first GUI framework, interactions in Flutter is based on gestures. There are two layers of the gesture system. The first layer has raw pointer events that describe the location and movement of pointers (for example, touches, mice, and styli) across the screen.The second layer has that describe semantic actions that consist of one or more pointer movements. Note that gestures include not only touches, but also all other pointer kinds on multi-platforms. gestures Since is a widget level visualization library, we chose the gestures layer as the foundation for the interaction system. The class carries information about a gesture. It is mainly used in s. Graphic Gesture GestureSignal The widely used widget that handles gestures in Flutter is the . It defines all the gesture types in its callback properties (like ), and developers are familiar with them. So inherits this taxonomy. The s of have same names (without the prefix) and meanings to their corresponding callback properties in GestureDetector, such as to . This keeps consistent with the Flutter gesture system and friendly to developers. GestureDetector onTap Graphic GestureType Graphic on GestureType.tap GestureDetector.onTap Graphic Signal To represent interactions, there are two levels of abstraction: and . These two concepts are referred to Vega, yet there are some differences in . signals selections Graphic s are also called "events" in some other systems. They are emitted when users or external changes interact with the chart. They carry information about the interaction. Signals are mainly used in updaters, like , or trigger selections internally. Signal RectCoord.horizontalRangeUpdater Although the same name, signals in have different meanings to . In Vega, signals are dynamic variables that parameterize a visualization, which means they provide values persistently, whether there are interactions or not. But in , signals are avatars of interactions, so they only occur when triggered and carry the whole information of the interaction, not only a variable value. Graphic signals in Vega Graphic Except the for user interactions, there are also and for the external changes that effects the chart, which are also "interactions" in a broad sense. GestureSignal ChangeDataSignal ResizeSignal Internally, different signals, no matter its kind or emitter, will be broadcasted by a reducer to all signal updaters. This makes developers unconstrained to decide which signal the updater will respond to. Selection A is a data query driven by gestures. They are the result of signals. When a selection is triggered, data tuples become either selected or unselected states, thus may causing their aesthetic attributes change if is defined. selection Attr.onSelection The rules of selections in are mainly from , so there are and . Graphic selections in Vega-Lite IntervalSelection PointSelection Unlike most other visualization libraries, a selection in is tested in data value space, not by graphical shape intersections. The pointer coordinates will be inverted into data values in each dimension, and these values will be searched in data list to find the results. This approach is more "data-driven" and performs better than shape intersection test in big data. Graphic Generally speaking, signals are raw and more flexible to use, while selections are more concise and focus on the data domain. Updater In , the basic idea of how interactions affect the chart is that they do not provide values to the chart directly, instead, they update existing property values in the chart and cause a reactive rendering. The calculation of property value and updating are in different operators, and the initial value (usually indicated in the specification) will be kept: Graphic Updaters are callback functions to update property values according to interactions, like or . Since there are two kinds of interaction, there are two kinds of updaters correspondingly, and : RectCoord.horizontalRangeUpdater Attr.updaters SignalUpdater SelectionUpdater SignalUpdater<V> = V Function(
  V initialValue,
  V preValue,
  Signal signal
)

SelectionUpdater<V> = V Function(
  V initialValue
) We can see that the advantage of such structure is that user can control the value status better by the initial value and prior value stored in the operators. Interaction Channel For common cases of interaction, features above are enough. But we introduced for advanced usage. interaction channels The interaction channel is a way for two-way communication with the chart. You can input and output interaction information through it. That is to say, you can manually emit a signal or selection to the chart and get noticed from the chart when a signal or selection occurs. It makes a more flexible and precise control of interaction. To achieve this, we consider about the idea of Functional Reactive Programming (FRP). Fortunately, the Dart language has a built-in , which is an simple implementation for FRP. The class can play the role of interaction channels. asynchronous stream system StreamController A good field to show the advantage of interaction channels is chart coupling. Think about that there are two different charts, coupling means when interacting with one chart, the other one acts the same, and vice versa. For example, two charts show the prices and volumes of a stock respectively, touch on one chart to show the auxiliary line, the other should show the same: You just need to let the two charts share the same gesture signal channel, and they will share all gestures, without any redundant input and output properties: final priceVolumeChannel = StreamController<GestureSignal>.broadcast();

// the price chart
Chart(
  ...
  gestureChannel: priceVolumeChannel,
)

// the volume chart
Chart(
  ...
  gestureChannel: priceVolumeChannel,
) Another example is two charts always select the same day: A shared selection channel of the two elements will do: final heatmapChannel = StreamController<Selected?>.broadcast();

// the above chart
Chart(
  ...
  elements: [PolygonElement(
    selectionChannel: heatmapChannel,
  )]
)

// the below chart
Chart(
  ...
  elements: [PolygonElement(
    selectionChannel: heatmapChannel,
  )]
) The complete code of the two examples above is . here Also Published Here

A Guide to Building Interactive Charts in Flutter

Here in Part Two of our three-part series, we continue to build on the fundamentals of Android development with the Salesforce Mobile SDK. , we covered project setup and creating a layout that fetches data from Salesforce, using Kotlin as our programming language of choice. In Part One Before we continue towards developing a complete mobile synchronization strategy, we’ll first build out our mobile app to allow editing and creating data on our Salesforce org. Editing Data With the view established, let’s see how we can edit the data. Ideally, we want to maintain the same list format, but make it such that if a user taps on a name, they can edit it. Those changes should then be sent back to Salesforce. To accomplish this, we need to do a few things. First, we need to override the default list behavior to make items editable. Then, after a record edit is complete, we need to make a call to the Salesforce API to update the data. As before, let’s start with the layout. Create a file in called and paste these lines into it: app/res/layout broker_item.xml <?xml version="1.0" encoding="utf-8"?>
<LinearLayout
   xmlns:android="http://schemas.android.com/apk/res/android"
   android:orientation="vertical"
   android:layout_width="fill_parent"
   android:layout_height="fill_parent">

   <EditText android:id="@+id/broker_field"
       android:layout_width="fill_parent"
       android:layout_height="wrap_content"
       />
</LinearLayout> Next, create a file in called , and paste this into it: app/java/com.example.sfdc BrokerListAdapter.kt package com.example.sfdc

import android.content.Context;
import android.text.Editable;
import android.text.TextWatcher;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ArrayAdapter;
import android.widget.EditText;
import com.salesforce.androidsdk.rest.BrokerItemBinding
import com.salesforce.androidsdk.rest.ApiVersionStrings
import com.salesforce.androidsdk.rest.RestClient
import com.salesforce.androidsdk.rest.RestRequest
import com.salesforce.androidsdk.rest.RestResponse

class BrokerListAdapter : ArrayAdapter<String> {
   internal var context: Context
   Private lateinit var brokerItemBinding: BrokerItemBinding
   private var client: RestClient? = null
   private val nameToId: MutableMap<String, String> = mutableMapOf()

   constructor(context: Context) : super(context, R.layout.broker_item, ArrayList<String>(0)) {
       this.context = context;
   }

   fun setClient(client: RestClient?) {
       this.client = client
   }

   fun map(name: String, id: String) {
       this.nameToId.put(name, id)
   }

   override fun getView(position: Int, convertView: View?, parent: ViewGroup): View {
       val inflater = context
           .getSystemService(Context.LAYOUT_INFLATER_SERVICE) as LayoutInflater
       brokerItemBinding = BrokerItemBinding.inflate(inflater)
       val rowView: View = inflater.inflate(R.layout.broker_item, parent, false)
       val brokerField = brokerItemBinding.brokerField
       var item = getItem(position)
       var brokerId = nameToId.get(item)
       val fields: MutableMap<String, String> =  mutableMapOf()

       brokerField.setText(item)
       brokerField.addTextChangedListener(object : TextWatcher {
           override fun beforeTextChanged(s: CharSequence, start: Int, count: Int, after: Int) {}
           override fun onTextChanged(s: CharSequence, start: Int, before: Int, count: Int) {}
           override fun afterTextChanged(s: Editable) {
               item = brokerField.text.toString()

               fields.put("Name", item!!)
               val restRequest = RestRequest.getRequestForUpdate(ApiVersionStrings.getVersionNumber(context), "Broker__c", brokerId,
                   fields as Map<String, Any>?
               )
               client?.sendAsync(restRequest, object : RestClient.AsyncRequestCallback {
                   override fun onSuccess(request: RestRequest, result: RestResponse) {}

                   override fun onError(exception: Exception) {}
               })
           }
       })
       return rowView
   }
} In the Android ecosystem, an adapter defines the functionality of a UI element. Here, we’ve created a new adapter that overrides certain behaviors of . We’ve added a function called , which reuses the same Salesforce API client that we need to populate the list over in . The function associates a broker’s name with their custom object ID—the reason why will be apparent soon. ArrayAdapter setClient MainActivity map is where the bulk of the activity happens. The most important line is the one dealing with . The client calls this to update Salesforce data; it requires the name of the custom object, its ID, and the value to replace (in this case, the name). This event occurs when fires; that is, after the user has finished updating the broker’s name. In a real production environment, you need to for potential errors from the API, but for the sake of brevity, we’ve omitted any type of response checking. getView RestRequest.getRequestForUpdate afterTextChanged check the status codes In , we need to make use of this adapter. First, at the top of the class definition, change to be a instead of an , like so: MainActivity listAdapter BrokerListAdapter ArrayAdapter class MainActivity : SalesforceActivity() {

   private var client: RestClient? = null
   private var listAdapter: ArrayAdapter<String>? = null
   private lateinit var listAdapter: BrokerListAdapter
    ... The modifier allows you to initialize a non-null type outside of the constructor. Next, replace the two functions with these: lateinit onResume override fun onResume() {
        // Hide everything until we are logged in
        mainViewBinding.root.visibility = View.INVISIBLE

        // Create list adapter
        listAdapter = BrokerListAdapter(this)
        mainViewBinding.brokersList.adapter = listAdapter

        super.onResume()
    }

    override fun onResume(client: RestClient) {
        // Keeping reference to rest client
        this.client = client
        listAdapter.setClient(client)

        // Show everything
        mainViewBinding.root.visibility = View.VISIBLE
        sendRequest("SELECT Name, Id FROM Broker__c")
    } Lastly, we need to keep track of the broker’s real name along with their record Id. To do that, we can simply store it in the dictionary the maintains. In , replace the for loop there with this one: BrokerListAdapter sendRequest for (i in 0..records.length() - 1) {
   listAdapter.add(records.getJSONObject(i).getString("Name"))
   listAdapter.map(records.getJSONObject(i).getString("Name"), records.getJSONObject(i).getString("Id"))
} Go ahead and launch the app, and your list items will be editable. Make an edit, and then get ready, because things are about to get wild. Go back to your scratch org, and click on the tab in the Dreamforce app. Your edits should be reflected here on the Salesforce platform! Brokers Adding Data We can edit records, but what if we need to add a new broker? The format for this is pretty similar to the logic we used for fetching and editing records. Let’s quickly go through the steps. Open up main.xml and paste these lines right before the : ListView <LinearLayout android:orientation="horizontal"
  android:layout_width="match_parent"
  android:layout_height="wrap_content"
  android:background="?android:colorBackground"
  android:layout_marginStart="10dp"
  android:layout_marginEnd="10dp"
  android:layout_marginTop="10dp"
  android:layout_marginBottom="10dp">

  <Button
     android:id="@+id/add_broker"
     android:layout_width="0dp"
     android:layout_height="47dp"
     android:onClick="onAddBrokerClick"
     android:text="Add broker"
     android:background="?android:colorPrimary"
     android:textColor="?attr/sfColorSecondary"
     android:layout_gravity="center"
     android:layout_weight="1"
     android:layout_marginEnd="10dp"/>
</LinearLayout> Here, we’ve added a button that will call a function called whenever it is pressed. In , we’ll define that method: onAddBrokerClick MainActivity fun onAddBrokerClick(v: View) {
   listAdapter.add("New Broker")
   var fields: Map<String, String> = mapOf("name" to "New Broker",
                                            "Title__c" to "Junior Broker",
                                            "Phone__c" to "555-555-1234",
                                            "Mobile_Phone__c" to  "555-555-1234",
                                            "Email__c" to "todo@salesforce.com",
                                            "Picture__c" to "https://cdn.iconscout.com/icon/free/png-256/salesforce-282298.png")
   val restRequest = RestRequest.getRequestForUpsert(ApiVersionStrings.getVersionNumber(this), "Broker__c", "Id", null, fields)

   client?.sendAsync(restRequest, object : AsyncRequestCallback {
       override fun onSuccess(request: RestRequest, result: RestResponse) {}
       override fun onError(exception: Exception) {}
   })
} Yes, that’s it! Those fields we’ve defined relate directly to the custom object. By setting to null, we’re telling the API that this is a new record. If you add a new row, edit it, and then head back to your scratch org, you’ll see the new data appear online. Id To Be Continued… Building on top of what we accomplished last time, in this post, we were able to edit and add broker data in our mobile app, and then see it reflected in Salesforce. Pretty neat! However, this is only a one-way data change—from the app to the org. What about sending data from the org to the app? In addition, how can we handle network issues that are unique to mobile phones, such as connectivity issues, or multiple people changing fields at the same time? We’ll address these very real concerns in our concluding post! First Published here

Building a Kotlin Mobile App with the Salesforce SDK: Editing and Creating Data - Part 2

Image Credit: wwardo@flickr The RxRecipes series generally refers to Android and , but the same recipes can apply to any Rx implementation and platform ( , , a backend with RxJava, etc). RxJava2 RxJs RxSwift Previous RxRecipe: Wrap your way to Rx Challenge: Reactive source from Lifecycle Events In my , I talked about a simple way to convert an imperative API to a reactive one (with fromCallable). There are many times however, where it isn’t that simple. previous article Imagine you need some component to react to A events. ctivity lifecycle Cleaning up a cache when your Activity stops. Recording a specific analytics event every time your Activity pauses. Binding some Android specific component (like a TextWatcher) to the Activity’s start. However, you immediately run into the problem of where to put your Rx code. There is no simple method or entry point. These hooks happen at different points, and can happen multiple times in different orders and sections depending on user input, application logic, and operating system events (like a facebook message pop-up triggering onPause()). We want to get to something like this: But how do we get there? The plan is coming together quite nicely… Muah-ha-ha-ha! Solution: Use a Subject! From the : official documentation Represents an Observer and an Observable at the same time, allowing multicasting events from a single source to multiple child Subscribers. Let’s review that: a Subject is BOTH an observer and observable. While Subjects have many possible use-cases, they are often used as a sort of multi-source emitter. We will take multiple sources (in this case multiple method callbacks) and pipe them all into a single concise subject. Subjects are great! They can hide the complexity of the input, and simplify the client API to treat it as a single source. Let’s see the code Note: Before we start with the code, it should be noted this is a pretty common approach to the Android lifecycle callbacks. For more examples see , or the recently open sourced . RxLifecycle from Trello Kickstarter Android App The first thing we need is some type to emit. We could create a class which can contain some state or meta-data (like included the saved instance state with the created event) but for simplicity let’s just use a simple enum. Bundle Now we just need to give the activity it’s own subject and push the proper instances of these events at the right time. We create the subject with .create() as soon as the new instance of the class is initialized We call onNext() to the subject with the appropriate event at the appropriate time Which Subject to Use? We use a here so that any subscriber immediately get’s the most recently emitted (current) lifecycle state of the activity. BehaviorSubject A simplified overview of the main included subjects in RxJava2 is as follows: : Emits the most emitted item and then immediately completes or errors. AsyncSubject : Emits the most recent item and then all subsequent items. BehaviorSubject : Emits all subsequent items. PublishSubject : Emits all of the items that have been emitted up to this point. ReplaySubject Don’t forget to .hide() We call hide() because we don’t want to mess with any of the internals of the behavior subject itself (like the underlying ). BehaviorDisposable When we unsubscribe we want to just dispose of the connection between the subject’s subscriber and and the subject. NOT the subject and it’s underlying subscription. Next in the RxRecipes Series: TBD — I’ll update this with a link to the next post once it’s done. Enjoy the recipe? Disagree with the implementation? Have burning-hot fiery opinions about some random sentence above? I’d love to hear from you, leave your comments below!

Stories, News & Mentions about HEATWATCH

Heatwatch’s Stories on HackerNoon