The Miami Heat have officially guaranteed Haywood Highsmith’s contract for the 2023-24 season, ESPN NBA insider Adrian Wojnarowski was first to report Thursday. The team had until July 15 whether or not to guarantee his 2023-24 salary, worth $1.9 million. Highsmith, 26, averaged 4.4 points and 3.5 rebounds in 17.9 minutes…

Way-too-early Miami Heat 2023-24 betting guide: Awards

The material is a molecule made of rhenium, selenium, and chlorine, and its called Re 6 Se 8 Cl 2. Its inventors say that a computer chip made with Re 6 Se 8 Cl 2 could transfer information twice as fast as one made with silicon. And surprisingly, that’s because it slows electrons down instead of speeding them up.

Scientists Accidentally Created Material for Superfast Computer Chips

Today, your Miami HEAT announced Carnival Cruise Line as its jersey patch sponsor for the 2023-2024 season. The agreement brings together two of the leading brands that have helped make Miami a ...

Miami HEAT and Carnival Cruise Lines Announce Jersey Patch Deal

While things are not currently that bad (at least not yet), studies on climate change repeatedly indicate that the heat-based premise of "Soylent Green" is rapidly becoming close to reality.

Heat is making our planet uninhabitable. Why isn't this the top news story around the world?

As temperatures drop, it's time to start thinking about turning on the heat. For homeowners, they get to decide when to finally give in and turn it on. For renters, it can be different.

Can your landlord control your heat, where to get help with heating bills and answers to other questions

The Miami Heat might be a point guard away from taking its roster to the next level. Could Tyus Jones of the Washington Wizards be that player? In his October 16 column, Greg Swartz of Bleacher ...

Heat Could ‘Change Championship Race’ By Trading for Starting PG, Analyst Says

All things being equal for Miami, based on team need, familiarity and the satisfaction of righting a wrong, signing free-agent guard Kendrick Nunn to fill the Miami Heat’s 14 th roster spot is ...

Miami Heat 14th Roster Spot: Erik Spoelstra Favorite Still a FA

Michael Mann's film Heat is a masterpiece of the crime genre, known for its depth of characters and intense performances by Al Pacino and Robert De Niro. Heat 2 is a sequel in the form of a novel ...

Heat 2: What is the Prequel/Sequel About?

The Miami Heat spend most of the offseason chasing Damian Lillard during free agency. The Heat failed in their attempt, with Lillard landing with the Milwaukee Bucks despite initially requesting ...

Miami Heat General Manager Andy Elisburg Discusses Offseason Of Damian Lillard Chase

Gov. Ron DeSantis’ declaration that all Palestinians are antisemitic was blasted by Democrats including U.S. Rep. Maxwell Frost, who asked why he didn’t condemn neo-Nazis in Florida with the ...

DeSantis takes heat from Democrats for calling all Palestinians antisemitic

Heat Inverse

heatinverse

Social media apps are perfect candidates for using graph databases and GraphQL APIs. The combinations of complex data queries and relationships are endless. Take Reddit for example. The app consists of “subreddits”, or topics. Users can create posts in these subreddits, which means that there is a many-to-one relationship between posts and subreddits. Each post belongs to exactly one subreddit, and each subreddit can contain many posts. Users can comment on posts, leading to another many-to-one relationship between posts and comments. Each comment belongs to exactly one post, and each post can have many comments. There is also a many-to-one relationship between users and posts and between users and comments. Each comment and post is made by a single user, and a single user can have many comments and posts. In an app like Reddit, each page of the app requires different subsets of this data. Using traditional REST API endpoints could mean developing several unique endpoints each tailored to meet the needs of a specific use case. GraphQL APIs, however, are based around the idea of having a single API endpoint that developers can use to pick and choose the relevant pieces of data they need for any given page. This article will highlight the flexibility of GraphQL and how easy using a hosted backend from makes it for frontend developers to get exactly the data they need for each page of their app. Dgraph Cloud Demo App — Readit The we’ll be using throughout the rest of the article is Readit, a Reddit clone, but for book lovers (…get it?). The app is built using: demo app for the UI React for the client-side routing React Router for the GraphQL backend and database Dgraph Cloud for facilitating the communication between the frontend and the backend Apollo Client As noted above, the basic data types in the app are subreddits (“subreadits”, ha…), posts, comments, and users. A diagram may be helpful to visually highlight the relationships between each of these nodes that make up our graph: Node relationships in the graph The app contains routes for viewing the home page, viewing a single subreadit, viewing a specific post, and viewing an individual user. Here we see the home page: Readit home page If you’d like to follow along at home or try this out on your machine, all of the . You can also . code for this app can be found on GitHub view the demo app here Configuring the Dgraph Cloud Backend Now that we have an overview of the app, let’s get started. First, we’ll create a backend with . For those not familiar with this service, Dgraph is a native GraphQL graph database built for the cloud. Dgraph Cloud With a little configuration, you get a graph database as well as an API endpoint for working with your database. Dgraph’s free tier is great for learning and getting started, so that’s what I used. More advanced features like shared and dedicated clusters are available on additional paid tiers if you need to make your backend production-ready. After signing in to our account, we click the “Launch a new backend” button, which will bring up the following setup page: Configuring a new Dgraph Cloud backend Since this is a demo app, we can choose the Starter option for the product type. Production apps should use a higher tier with a shared or dedicated instance though. I left my region as “us-west-2”, since that’s the region closest to me. I used “reddit-clone” for the name, but feel free to use whatever you like. After filling out all the options, we can click “Launch” to spin up the new backend. Once the backend has been created, we’ll see an overview page with the new backend API endpoint: New backend API endpoint Now it’s time to build a schema. This schema declares the various types of data that we’ll be working with in our app and storing in our database. We can either enter our schema info directly in the Schema Editor, or, for a more interactive experience, use UI Mode. Let’s use UI Mode to create our schema. The GUI helps us configure our types, their fields, and even the relationship between various types and fields. Creating a schema in UI Mode After creating the schema, we can click the “Deploy” button to make it official. If we now look at the Schema Editor view, we’ll see the resulting GraphQL snippet: As you can see, each field has an associated type. For instance, the type we created has an field that contains a unique identifier generated by Dgraph Cloud. It has a field which contains the string text entered by the user. It has a field which is an integer representing the number of votes the comment has received. Finally, the field references the user that wrote the comment, and the field references the post on which the comment was made. Comment id commentContent voteCount user post The relationship between the comment and the user is designated by the directive which tells Dgraph Cloud that the type is linked to the type by the field on the type. The same is true for the relationship between the comment and the post. @hasInverse Comment User comments User You’ll also notice that a few of our fields include the directive. This allows us to filter our queries by these searchable fields. For instance, we can find a specific subreddit by filtering our query results by a specific string of text for the field. The same is true when filtering user results by their field. @search name userName The next step is to populate the database with some seed data, which we can do using the API Explorer. We won’t go through all the mutations necessary to populate the data in this article, but you can . These snippets are used to create the subreadits, users, posts, and comments. view the GraphQL snippets here For example, here’s what I used to create a few subreadits: Configuring the Frontend Now that we have the backend created, we can move along to building the frontend. We’ll use to generate a skeleton app as a starting point and then continue to build upon the app from there. create-react-app yarn create react-app reddit-clone reddit-clone cd Next, we’ll install so that we can do client-side routing in the single page app with React Router: react-router-dom yarn add react-router-dom Using React Router, we can create routes for each of our pages: home, subreadit, post, and user. Below is the component with each of its routes: App Then, we’ll install a couple of packages for , which is a JavaScript state management library for working with GraphQL. While it’s possible to make requests to a GraphQL API endpoint directly using something like the API, Apollo Client makes this process even simpler. Apollo Client fetch yarn add @apollo/client graphql (You’ll note that we’ve installed the package as well as the package, even though we never directly use the package in our code. This is because is a of and is used internally to facilitate working with GraphQL in JavaScript.) graphql @apollo/client graphql graphql peerDependency @apollo/client Now that we have Apollo Client installed, we can easily query data from the GraphQL backend and consume it in our React components. We can first create the Apollo client like so: And then we can wrap our main component in the in the file: App ApolloProvider index.js Home Page Now that we have our routing set up and Apollo ready to go, we can begin building the pages for each of our routes. The home page shows a list of popular subreadits and a list of popular users. Readit home page We can query our endpoint for that information and then use Apollo to declaratively handle the , , and data states. The code for the component is reproduced in full below: loading error response HomePage Note how when retrieving the user info, we don’t need to fetch all of the user’s posts and comments. The only thing we’re interested in for the home page is how many posts and how many comments each user has. We can use the field from and to find the relevant numbers. count postsAggregate commentsAggregate Subreadit Page If we click on one of the subreadits from the home page, we’ll be taken to that particular subreadit’s page where we can see all the posts under that topic. Readit subreadit page for the 1984 subreadit On this page, we need the data for the subreadit name and description, just like we did on the home page. We now also need to fetch all of the posts that are part of this subreadit. For each post, we need the post title, the number of votes and comments, and the username of the user who posted it. We don’t need the actual comments yet though since they’re not displayed on this page. Here’s the code for the component: SubreaditPage Post Page Once we’ve found an interesting post we’d like to view, we can click on the link to view the individual post page. This page shows us the original post as well as all of the comments on the post. Readit post page for Oscar’s post Here we need all the same post data that we did on the subreadit page, but now we also need to know the subreadit it was posted on, and we need all of the comments on the post. For each comment, we need to know the username for the user who posted it, what the actual comment content was, and how many votes it has. The code for the looks like this: PostPage User Page Finally, if we decide to view a user’s profile, we can see all of their posts and comments they’ve made. Readit user page for Oscar Martinez This page should show the user’s username, bio, number of posts, and number of comments. We also need all of their posts and all of their comments. On each post, we need to know the subreadit it was posted on, the post title, as well as the number of votes and comments. For each comment, we need to know which post it was a comment on, what the comment content was, and the number of votes it’s received. The code for the is below: UserPage This page is by far the most complex, as we need to query more than just summary data or aggregate count data. Conclusion As we’ve seen, each page in our app requires unique portions of data. Some pages need only high-level summaries, like the number of comments or posts a user has made. Other pages need more in-depth results, like the actual comments and actual posts. Depending on the page, you may need more or less information. The benefit of using GraphQL and Dgraph Cloud is the flexibility in querying exactly the data we need for each page — no more and no less. For each request, we used the same single API endpoint but requested different fields. This greatly simplifies the development work as we don’t need to create a new backend endpoint for each page. (Or worse, create a single endpoint that retrieves a monstrous payload of data we then have to sift through to find the minor subset of data that we need.) GraphQL makes it easy to quickly and painlessly request exactly the right data exactly when you need it. . Also published behind a paywall

How to Build a Reddit Clone with React and Dgraph Cloud

Memes are one of my favorite things about the Internet. They are a virtual postcard capturing moments of Internet history ... from a comical perspective. For those who are not quite sure what a "meme" is, uses the following definition: Ben Stegner "A piece of media, often humorous, that spreads rapidly through the internet." In fact, in this context, memes are actually as defined by Wikipedia: Internet Memes "A type of idea, behavior, or style (meme) that is spread via the internet, often through social media platforms and especially for humorous purposes." The original meme design included some form of a photo, with text above and below the image using the Impact font face. Here is a classic example from the original movie: Willy Wonka & the Chocolate Factory For the last few months, the following photo taken of Bernie Sanders has been the subject of several memes: In this example, Bernie is placed on Mars shortly after the landed: Mars 2020 rover In fact, one of my teammates (named ) actually shaved his head in a male-pattern baldness manner just to create the following presence during a team meeting: Kurtis My biggest challenge, from working long hours each week and fathering a toddler, is keeping up with the most-recent memes. So I began to wonder, "what if there was a social media app focused on providing the most popular or trending memes?" Since I am continuing to learn more about GraphQL, I thought I would prototype an Instagram-like clone for sharing memes. Creating InstaMeme For the most part, I really enjoy what social media applications provide to society. They have allowed me to reconnect/stay connected with friends and colleagues, sharing updates for all to see. This is far better than using an alternative, like email. While I know that Instagram, Twitter, and Facebook allow sharing photos, I feel like I am still missing out on so many funny memes. I believe the underlying design of the popular social media applications is not truly focused on making sure I keep current on what everyone else thinks is worth sharing. For that reason, I wanted to prototype something I will refer to as "InstaMeme". It's similar to Instagram but focused on keeping everyone up to date with the latest/trending memes. For the record, I am not really planning to build this application, but rather using it as an idea to prototype some data. When adding memes to InstaMeme, the end user must select from a list of categories. Below is a list of the categories I thought would be valid: animals pop culture movies music sports Consider this basic application mockup for the InstaMeme user interface: When users load the application, they will be presented with a list of memes that they have not previously ranked. The application will show the highest-ranked memes first, based upon the overall ratings of all memes which have not been seen by the user. Using the filter button, the application also allows the user to focus on a specific category. Where Instagram has a Heart button and Facebook has Like and Love buttons, InstaMeme takes things a step further to allow the following responses for a provided meme: Why GraphQL? Graph databases are a great solution when the relationships (edges) between your data (nodes) are just as important as the data itself. This is the core reason why social media applications utilize this database type. The same principles will apply with the InstaMeme application: Each user will maintain a profile. Memes are uploaded and rated by the user's profile. Each meme will require a category for classification. To provide a top-notch user experience, it would be nice for a profile to maintain relationships with the memes that have been uploaded or rated. The category options should have the ability to see which meme objects link to each category name. Each meme object should have a relationship with both the category and profile objects as well. For this project, I wanted to leverage a single service to house the InstaMeme data and provide API URIs which can access the GraphQL data. I decided to go with Dgraph's fully-managed backend service, called . It's a hosted, native GraphQL solution, which can be utilized via their free tier (with limited data transfer) or 7-day free trial (credit card required) by using the following link: Slash GraphQL https://cloud.dgraph.io/ Once I created the backend service, initializing my environment only took a few seconds: instameme Schema Creation and Relationships Based upon the initial requirements noted above, I created the following schema in Dgraph Slash GraphQL to house the InstaMeme data: type Category  { : ! @search(by:[hash]) @id
	memes: [Meme] @hasInverse(field:category)
}

type Profile  { : ! @search(by:[hash]) @id
	memes: [Meme] @hasInverse(field:created_by)
	ratings: [Rating] @hasInverse(field:by)
}

type Meme  { : ! @search(by:[fulltext]) @id
 	title: category: Category! @hasInverse(field:memes)
	created_by: Profile! @hasInverse(field:memes)
	rank: Float
	ratings: [Rating] @hasInverse(field:about)
}

type Rating  { : ID!
	about: Meme!
	by: Profile!
	score: Int @search
}

type Query  {
	mostRecommendedMemes(handle: ): [Meme] @lambda
} name String handle String image_url String String id String While the scheme is pretty straight-forward to understand, the following directives have been employed: - used to annotate a field that represents a unique identifier coming from outside of Dgraph @id - allows filtering on a field while querying for nodes @search - is used to setup up two-way edges such that adding an edge in one direction automatically adds the one in the inverse direction @hasInverse - allows custom JavaScript resolvers to be utilized @lamba Creating a Lambda For Advanced Functionality To present the highest-rated items first, the support team at Dgraph helped me to create the mostRecommendedMemes Lambda function. Lambda provides a way to write your custom logic in JavaScript, integrate it with your GraphQL schema, and execute it using the GraphQL API. In fact, Lambda directive and custom directive are the most powerful features that Slash provides. This allows developers to build any business logic within Slash. In this example, the Lambda utilizes the aggregate average of all the meme ratings. I continued down the Lambda path to introduce filtering out memes which were uploaded by a user or already rated with a score: { .log( , args); results = graphql( ) memeList = results.data.queryMeme; filteredList = []; (memeList && memeList.length > ) { (meme memeList) { (meme.created_by.handle !== args.handle && canRate(meme.ratings, args.handle)) { (meme && meme.ratings && meme.ratingsAggregate != && meme.ratingsAggregate.scoreAvg != ) {
          meme.rank = meme.ratingsAggregate.scoreAvg;
        } {
          meme.rank = ;
      	}

        filteredList.push(meme);
      }
    } (filteredList.length > ) {
      filteredList.sort( { b.rank - a.rank})
    }
  } .log( , filteredList); filteredList;
} { .log( , ratings, handle); (ratings && ratings.length > ) { (rating ratings) { .log( , rating); (rating.by.handle == handle) { .log(handle + + rating.score + ); ;
      }
    } .log(handle + ); ;
  } { .log( ); ;
  }
}

self.addGraphQLResolvers({ : mostRecommendedMemes
}) async ( ) function mostRecommendedMemes {args, graphql} console 'started mostRecommendedMemes()' const await `query mostRecommendedMemes {
  queryMeme {
    title
    rank
    image_url
    category {
      name
    }
    ratings {
      score
      by {
        handle
      }
    }
    created_by {
      handle
    }
    ratingsAggregate {
      count
      scoreAvg
    }
  }
}` const let if 0 for of if if null null else 0 if 1 ( ) => a, b return console 'finished mostRecommendedMemes()' return ( ) function canRate ratings, handle console 'canRate()' if 0 for of console 'rating' if console ' already rated this meme with a score=' ', returning false' return false console ' has not rated this meme, returning true' return true else console 'no ratings, returning true' return true "Query.mostRecommendedMemes" By adding the business logic into the Lambda, the need to utilize another application server (or performing more work on the client side) is completely avoided. Adding Data to Slash GraphQL With the schema and lambda in place, I quickly populated some basic category information: mutation {
addCategory(input: [
  { : },
  { : },
  { : },
  { : },
  { : }]) {
  category {
    name
  }
 }
} name "animals" name "pop-culture" name "movies" name "music" name "sports" Next, a few unique User records can be created: mutation {
addProfile(input: [
  { : },
  { : },
  { : },
  { : },
  { : }]) {
  profile {
    handle
  }
 }
} handle "aUser" handle "jv" handle "matt" handle "MontyMeme" handle "russell" The Dgraph Slash GraphQL service provides an API Explorer user interface which allows an easy mechanism to perform data insertions into the GraphQL database. Using the internet, I decided to use the following memes: Using the original URLs for each image (which may not work over time), the meme data can be  added to the Slash database using the following statement: mutation {
 addMeme(input: [{ : , : , : { : }, : { : }},
   { : , : , : { : }, : { : }
   },
   { : , : , : { : }, : { : }
   },
   { : , : , : { : }, : { : }
   }
   ])
 {
   meme {
     image_url
     title
     category { name }
     created_by { handle }
   }
 }
} image_url "https://imgs.classicfm.com/images/214366?crop=16_9&width=660&relax=1&signature=9AmHbXaI3PYP8iYH4JqaNChosWg=" title "Bernie: The Audition Panel Before You Even Start Singing" category name "pop-culture" created_by handle "russell" image_url "https://media.makeameme.org/created/when-you-find-76a8a4d633.jpg" title "When You Find Out You Have No Money" category name "movies" created_by handle "matt" image_url "https://static.thehoneycombers.com/wp-content/uploads/sites/4/2020/03/Best-funny-Coronavirus-memes-2020-Honeycombers-Bali-9.jpg" title "When You Find Out Your Normal Daily LifeStyle Is Called 'Quarantine'" category name "pop-culture" created_by handle "MontyMeme" image_url "https://ruinmyweek.com/wp-content/uploads/2020/03/tiger-king-memes-1.jpg" title "Tiger King: The Real Criminal Is Whoever's Cutting Hair In Wynnewood" category name "pop-culture" created_by handle "russell" The above mutation was designed to insert data into the GraphQL database. If a larger data set was required to be added, query variables could be utilized for a cleaner approach. For more information, please review the following URL: Dgraph | Add Mutations Next, I used the following grid to establish some existing ratings: The ratings can be translated into mutations to insert data into Slash GraphQL: mutation {
 addRating(input: [
  { : { : }, : { : }, : },
  { : { : }, : { : }, : },
  { : { : }, : { : }, : },
  { : { : }, : { : }, : },
  { : { : }, : { : }, : },
  { : { : }, : { : }, : },
  { : { : }, : { : }, : },
  { : { : }, : { : }, : },
  { : { : }, : { : }, : },
  { : { : }, : { : }, : },
  { : { : }, : { : }, : },
  { : { : }, : { : }, : }
  ])
 {
   rating {
     about { image_url }
     by { handle }
     score
   }
 }
} about image_url "https://imgs.classicfm.com/images/214366?crop=16_9&width=660&relax=1&signature=9AmHbXaI3PYP8iYH4JqaNChosWg=" by handle "aUser" score 4 about image_url "https://imgs.classicfm.com/images/214366?crop=16_9&width=660&relax=1&signature=9AmHbXaI3PYP8iYH4JqaNChosWg=" by handle "matt" score 4 about image_url "https://imgs.classicfm.com/images/214366?crop=16_9&width=660&relax=1&signature=9AmHbXaI3PYP8iYH4JqaNChosWg=" by handle "MontyMeme" score 4 about image_url "https://media.makeameme.org/created/when-you-find-76a8a4d633.jpg" by handle "aUser" score 3 about image_url "https://media.makeameme.org/created/when-you-find-76a8a4d633.jpg" by handle "MontyMeme" score 4 about image_url "https://media.makeameme.org/created/when-you-find-76a8a4d633.jpg" by handle "russell" score 4 about image_url "https://static.thehoneycombers.com/wp-content/uploads/sites/4/2020/03/Best-funny-Coronavirus-memes-2020-Honeycombers-Bali-9.jpg" by handle "jv" score 4 about image_url "https://static.thehoneycombers.com/wp-content/uploads/sites/4/2020/03/Best-funny-Coronavirus-memes-2020-Honeycombers-Bali-9.jpg" by handle "matt" score 3 about image_url "https://static.thehoneycombers.com/wp-content/uploads/sites/4/2020/03/Best-funny-Coronavirus-memes-2020-Honeycombers-Bali-9.jpg" by handle "russell" score 3 about image_url "https://ruinmyweek.com/wp-content/uploads/2020/03/tiger-king-memes-1.jpg" by handle "aUser" score 3 about image_url "https://ruinmyweek.com/wp-content/uploads/2020/03/tiger-king-memes-1.jpg" by handle "matt" score 2 about image_url "https://ruinmyweek.com/wp-content/uploads/2020/03/tiger-king-memes-1.jpg" by handle "MontyMeme" score 4 At this point, a base dataset exists to demonstrate the InstaMeme prototype. Interacting with Slash GraphQL Since Dgraph's Slash GraphQL provides GraphQL as a service, all the necessary service interaction to communicate with the GraphQL API is enabled and ready as soon as I created a new backend service called "instameme" on . https://slash.dgraph.io/ Using the built-in functionality of Slash GraphQL, the InstaMeme application can simply make the following query against the Dgraph Slash GraphQL service. In fact, the only requirement for the InstaMeme client is that it can make GraphQL API calls to the Dgraph SaaS. To retrieve the most recommended memes for my user handle (“jv”), I submit the following query to the Slash GraphQL service: query MyQuery {
  mostRecommendedMemes(handle: ) {
    title
    rank
    image_url
  }
} "jv" This only returns the three memes which I have not yet rated: { : { : [
      { : , : , : },
      { : , : , : },
      { : , : , : }
    ]
  }, : { : { : , : , : , : }
  }
} "data" "mostRecommendedMemes" "title" "Bernie: The Audition Panel Before You Even Start Singing" "rank" 4 "image_url" "https://imgs.classicfm.com/images/214366?crop=16_9&width=660&relax=1&signature=9AmHbXaI3PYP8iYH4JqaNChosWg=" "title" "When You Find Out You Have No Money" "rank" 3.666667 "image_url" "https://media.makeameme.org/created/when-you-find-76a8a4d633.jpg" "title" "Tiger King: The Real Criminal Is Whoever's Cutting Hair In Wynnewood" "rank" 3 "image_url" "https://ruinmyweek.com/wp-content/uploads/2020/03/tiger-king-memes-1.jpg" "extensions" "tracing" "version" 1 "startTime" "2021-02-21T20:19:15.13150208Z" "endTime" "2021-02-21T20:19:15.169366131Z" "duration" 37864074 Notice that Slash GraphQL sorts the results from the highest rank to the lowest rank. If I were to pass in the handle of a new user (newUserPerson), the request would appear as: query MyQuery {
  mostRecommendedMemes(handle: ) {
    title
    rank
    image_url
  }
} "newUserPerson" Since none of the existing memes were uploaded by newUserPerson or ranked, all four meme records will appear (in the correct order): { : { : [
      { : , : , : },
      { : , : , : },
      { : , : , : },
      { : , : , : }
    ]
  }, : { : { : , : , : , : }
  }
} "data" "mostRecommendedMemes" "title" "Bernie: The Audition Panel Before You Even Start Singing" "rank" 4 "image_url" "https://imgs.classicfm.com/images/214366?crop=16_9&width=660&relax=1&signature=9AmHbXaI3PYP8iYH4JqaNChosWg=" "title" "When You Find Out You Have No Money" "rank" 3.666667 "image_url" "https://media.makeameme.org/created/when-you-find-76a8a4d633.jpg" "title" "When You Find Out Your Normal Daily LifeStyle Is Called 'Quarantine'" "rank" 3.333333 "image_url" "https://static.thehoneycombers.com/wp-content/uploads/sites/4/2020/03/Best-funny-Coronavirus-memes-2020-Honeycombers-Bali-9.jpg" "title" "Tiger King: The Real Criminal Is Whoever's Cutting Hair In Wynnewood" "rank" 3 "image_url" "https://ruinmyweek.com/wp-content/uploads/2020/03/tiger-king-memes-1.jpg" "extensions" "tracing" "version" 1 "startTime" "2021-02-21T20:20:59.525924536Z" "endTime" "2021-02-21T20:20:59.540636745Z" "duration" 14712230 This is just a simple example of how the flexibility and power of a GraphQL database can meet the needs of a social media application, like the InstaMeme application. The Point Where Slash GraphQL Saves Me Using Dgraph Slash GraphQL, I was able to initialize a new backend service, create a schema, and insert sample data for prototyping in a very short time. At no cost, I was able to focus on prototyping my idea rather than worrying about multiple service layers. If desired, I could have elected to use the open-source version of Dgraph's graph database, by selecting one of the local options at the following URL: https://dgraph.io/downloads Schema updates are always quick and easy, which is a huge benefit of using GraphQL over alternate solutions. In fact, in my early design, I had not considered the importance of the category object. I simply updated and submitted my schema enhancements in a matter of minutes, then returned my focus on application development. I also added the "title" attribute to the meme object, while I was writing this article because I felt it would be difficult to keep track of each unique URL. If I was using an RDBMS like Oracle or MS SQL, this simple change could have disrupted my entire object model, causing me days of refactoring and unit testing. But with Slash GraphQL, it took just a few minutes. Conclusion As I continue to dive deeper into GraphQL, I reflect on prior projects which would benefit from a graph database aspect. This does not mean a conversion from a relational database to a graph database, but a coexistence—where each technology is the best solution. In the 30 years I have been an IT professional, I have seen this same approach with client and service frameworks. There is no reason why the database layer should not maintain the same view. Have a really great day! Also published at https://dzone.com/articles/using-slash-graphql-to-create-instamemea-meme-shar

Creating A Meme Sharing App Using Slash GraphQL

Tracking the Worst Sci-Fi Movies With Angular and Slash GraphQL

[TL;DR; Get started using Dgraph's Slash GraphQL product and connect to a Spring Boot application which will act as a simple RESTful recommendation service.] Back in the early 2000s, I was working on a project implementing an eCommerce solution by (ATG), now owned by Oracle.  The ATG Dynamo product was an impressive solution as it included a persistence layer and a .  At the time, companies like Target and Best Buy used the Dynamo solution, leveraging the scenario module to provide recommendations to the customer. Art Technology Group scenarios module As an example, the Dynamo eCommerce solution was smart enough to remember when a customer added a product to their cart and later removed it.  As an incentive, the scenario server could be designed to offer the same customer a modest discount on a future visit if they re-added the product into their cart and purchased it within the next 24 hours. Since those days, I have always wanted to create a simple recommendations engine, which is my goal for this publication. About the Recommendations Example I wanted to keep things simple and create some basic domain objects for the recommendations engine.  In this example, the solution will make recommendations for musical artists and the underlying Artist object is quite simple: { String name;
} @AllArgsConstructor @NoArgsConstructor @Data public class Artist private In a real system, there would be so many more attributes to track. However, in this example, the name of the artist will suffice. As one might expect, customers will rate artists on a scale of 1 to 5, where a value of five represents the best score possible.  Of course, it is possible (and expected) that customers will not rate every artist.  The customer will be represented (again) by a very simple Customer object: { String username;
} @AllArgsConstructor @NoArgsConstructor @Data public class Customer private The concept of a customer rating an artist will be captured in the following Rating object: { String id; score; Customer by; Artist about;
} @AllArgsConstructor @NoArgsConstructor @Data public class Rating private private double private private In my normal Java programming efforts I would likely use private Customer customer and private Artist artist for my objects, but I wanted to follow the pattern employed by graph databases, where I employ variables like `by` and `about` instead..  This should become more clear as the article continues. Dgraph Slash GraphQL With the popularity of graph databases, I felt like my exploration of creating a recommendations engine should employ a graph database.  After all, GraphQL has become a popular language for talking to services about graphs.  While I only have some knowledge around graph databases, my analysis seemed to conclude that a graph database is the right choice for this project and is often the source for real-world services making recommendations. Graph databases are a great solution when the relationships (edges) between your data (nodes) are just as important as the data itself—and a recommendation engine is the perfect example. However, since I'm just starting out with graph databases, I certainly didn't want to worry about starting up a container or running a GraphQL database locally.  Instead I wanted to locate a SaaS provider.  I decided to go with Dgraph's fully-managed backend service, called .  It's a hosted, native GraphQL solution. The Slash GraphQL service was just released on September 10th, 2020 and can be enabled by using the following link. The platform offers a free trial which will work for this article (then moves to a $9.99/mo flat fee for up to 5GB data). Slash GraphQL https://slash.dgraph.io/ After launching this URL, a new account can be created using the normal authorization services: In my example, I created a backend called "spring-boot-demo" which ultimately resulted in the following dashboard: The process to get started was quick and free, making it effortless to configure the Slash GraphQL service. Configuring Slash GraphQL As with any database solution, we must write a schema and deploy it to the database.  With Slash GraphQL, this was quick and easy: { : String! ( : [hash, regexp]) : [Rating] ( : about)
} { : String! ( : [hash, regexp]) : [Rating] ( : by)
} { : ID! : Artist! : Customer! : Int } type Artist name @id @search by ratings @hasInverse field type Customer username @id @search by ratings @hasInverse field type Rating id about by score @search In fact, my original design was far more complex than it needed to be, and the level of effort behind making revisions was far easier than I expected.  I quickly began to see the value as a developer to be able to alter the schema without much effort. With the schema in place, I was able to quickly populate some basic Artist information: mutation {
 addArtist(input: [
   {name: },
   {name: },
   {name: },
   {name: },
   {name: },
   {name: },
   {name: }]) {
   artist {
     name
   }
 }
} "Eric Johnson" "Genesis" "Led Zeppelin" "Rush" "Triumph" "Van Halen" "Yes" At the same time, I added a few fictional Customer records: mutation {
 addCustomer(input: [
   {username: },
   {username: },
   {username: },
   {username: },
   {username: }]) { {
     username
   }
 }
} "Doug" "Jeff" "John" "Russell" "Stacy" customer As a result, the five customers will provide ratings for the seven artists, using the following table: An example of the rating process is shown below: mutation {
 addRating(input: [{
   by: {username: },
   about: { name: },
   score: }])
 {
   rating {
     score
     by { username }
     about { name }
   }
 }
} "Jeff" "Triumph" 4 With the Slash GraphQL data configured and running, I can now switch gears and work on the Spring Boot service. The Slope One Ratings Algorithm In 2005, a by Daniel Lemire and Anna Maclachian introduced the Slope One family of collaborative filtering algorithms.  This simple form of item-based collaborative filtering looked to be a perfect fit for a recommendations service, because it takes into account ratings by other customers in order to score items not rated for a given customer. research paper In pseudo-code, the Recommendations Service would achieve the following objectives: retrieve the ratings available for all artists (by all customers) create a Map<Customer, Map<Artist, Double>> from the data, which is a customer map, containing all the artists and their ratings the rating score of 1 to 5 will be converted to a simple range between 0.2 (worst rating of 1) and 1.0 (best rating of 5). With the customer map created, the core of the Slope One ratings processing will execute by calling the SlopeOne class: populate a Map<Artist, Map<Artist, Double>> used to track differences in ratings from one customer to another populate a Map<Artist, Map<Artist, Integer>> used to track the frequency of similar ratings use the existing maps to create a Map<Customer, HashMap<Artist, Double>> which contain projected ratings for items not rated for a given customer For this example, a random Customer is selected and the corresponding object from the Map<Customer, HashMap<Artist, Double>> projectedData map is analyzed to return the following results: { : { : }, : { : , : , : , : }, : { : , : , : }, : { : , : , : , : , : , : , : }
} "matchedCustomer" "username" "Russell" "recommendationsMap" "Artist(name=Eric Johnson)" 0.7765842245950264 "Artist(name=Yes)" 0.7661904474477843 "Artist(name=Triumph)" 0.7518039724158979 "Artist(name=Van Halen)" 0.7635436007978691 "ratingsMap" "Artist(name=Genesis)" 0.4 "Artist(name=Led Zeppelin)" 1.0 "Artist(name=Rush)" 0.6 "resultsMap" "Artist(name=Eric Johnson)" 0.7765842245950264 "Artist(name=Genesis)" 0.4 "Artist(name=Yes)" 0.7661904474477843 "Artist(name=Led Zeppelin)" 1.0 "Artist(name=Rush)" 0.6 "Artist(name=Triumph)" 0.7518039724158979 "Artist(name=Van Halen)" 0.7635436007978691 In the example above, the "Russell" user was randomly selected.  When looking at the original table (above), Russell only provided ratings for Genesis, Led Zeppelin, and Rush.  The only artist that he truly admired was Led Zeppelin.  This information is included in the ratingsMap object and also in the resultsMap object. The resultsMap object includes projected ratings for the other four artists: Eric Johnson, Yes, Triumph, and Van Halen.  To make things easier, there is a recommendationsMap included in the payload, which includes only the artists that were not rated by Russell. Based upon the other reviews, the Recommendations Service would slightly favor Eric Johnson over the other four items—with a score of 0.78, which is nearly a value of four in the five-point rating system. The Recommendations Service In order to use the Recommendations Service, the Spring Boot server simply needs to be running and configured to connect to the Slash GraphQL cloud-based instance.  The GraphQL Endpoint on the Slash GraphQL Dashboard can be specified in the application.yml as slash-graph-ql.hostname or via passing in the value via the ${SLASH_GRAPH_QL_HOSTNAME} environment variable. The basic recommendations engine can be called using the following RESTful URI: - {spring-boot-service-host- }/recommend GET name This action is configured by the RecommendationsController, as shown below: @GetMapping(value = )
public ResponseEntity<Recommendation> recommend() { ResponseEntity<>(recommendationService.recommend(), HttpStatus.OK);
   } (Exception e) ResponseEntity<>(HttpStatus.BAD_REQUEST);
   }
} "/recommend" try return new catch return new Which calls the RecommendationService: @Slf4j
@RequiredArgsConstructor
@Service
public {
   private final ArtistService artistService;
   private final CustomerService customerService;
   private final SlashGraphQlProperties slashGraphQlProperties
   private final RATING_QUERY = ;
   public Recommendation recommend() throws Exception {
       ResponseEntity< > responseEntity = RestTemplateUtils.query(slashGraphQlProperties.getHostname(), RATING_QUERY); {
           ObjectMapper objectMapper = ObjectMapper();
           SlashGraphQlResultRating slashGraphQlResult = objectMapper.readValue(responseEntity.getBody(), SlashGraphQlResultRating.class);
           log.debug( , slashGraphQlResult); makeRecommendation(slashGraphQlResult.getData());
       } (JsonProcessingException e) { Exception( + responseEntity.getBody(), e);
       }
   }
...
} class RecommendationService static String "query RatingQuery { queryRating { id, score, by { username }, about { name } } }" String try new "slashGraphQlResult={}" return catch throw new "An error was encountered processing responseEntity=" Please note - something that might be missed at a quick glance of this code, is the power and ease in being able to pull out a subgraph to perform the recommendation.  In the example above, the line is providing a subgraph to the method. slashGraphQlResult.getData() makeRecommendation() The RATING_QUERY is the expected Slash GraphQL format to retrieve Rating objects.  The RestTemplateUtils.query() method is part of a static utility class, to keep things DRY (don't repeat yourself): public final {
   private RestTemplateUtils() { }
   private final MEDIA_TYPE_GRAPH_QL = ;
   private final GRAPH_QL_URI = ;
   public ResponseEntity< > query( hostname, query) {
       RestTemplate restTemplate = RestTemplate();
       HttpHeaders headers = HttpHeaders();
       headers.setContentType(MediaType.valueOf(MEDIA_TYPE_GRAPH_QL));
       HttpEntity< > httpEntity = HttpEntity<>(query, headers); restTemplate.exchange(hostname + GRAPH_QL_URI, HttpMethod.POST, httpEntity, .class);
   }
} class RestTemplateUtils static String "application/graphql" static String "/graphql" static String String String new new String new return String Once the slashGraphQlResult object is retrieved, the makeRecommendation() private method is called, which returns the following Recommendation object. (This was shown above in JSON format): @AllArgsConstructor
@NoArgsConstructor
@Data
public {
   private Customer matchedCustomer;
   private HashMap<Artist, Double> recommendationsMap;
   private HashMap<Artist, Double> ratingsMap;
   private HashMap<Artist, Double> resultsMap;
} class Recommendation Conclusion In this article, an instance of Dgraph Slash GraphQL was created with a new schema and sample data was loaded.  That data was then utilized by a Spring boot service which served as a basic recommendations engine.  For those interested in the full source code, please review the . GitLab repository From a cost perspective, I am quite impressed with the structure that Slash GraphQL provides.  The new account screen indicated that I have 10,000 credits to use, per month, for no charge.  In the entire time I used Slash GraphQL to prototype and create everything for this article, I only utilized 292 credits.  For those needing more than 10,000 credits, $45 (USD) per month allows for 100,000 credits and $99 (USD) per month allows for 250,000 credits. Using a graph database for the first time did present a small learning curve and I am certain there is far more than I can learn by continuing this exercise.  I felt that Slash GraphQL exceeded my expectations with the ability to change the schema as I learned more about my needs.  As a feature developer, this is a very important aspect that should be recognized, especially compared to the same scenario with a traditional database. In my next article, I'll introduce an Angular (or React) client into this process, which will interface directly with GraphQL and the Recommendation Service running in Spring Boot. (Published with the kind permission of the original author, John Vester )

An Awesome Tool To Quickly Create An Amazon-Like Recommendation Engine 

A Great Way To Create A Brilliant GraphQL-Powered Blog

“ If you want to glimpse the future of retail, check out an Amazon Go store.” Hahahahaha *inhales* HAHAHAHAHAHA Damn it, CNN, you can’t do me like this. The idea behind Amazon GO is theoretically simple : customers download an app ( ), link it to a credit card, generate a unique code and present it at the shop’s entrance. Once the turnstiles open, they are free to shop, unbothered by human interactions; cameras follow them around, tracking what is picked up using computer vision algorithms, and smart shelves equipped with a variety of sensors confirm what the cameras “see”. The items are added to a virtual basket, and clients are automatically charged as they exit the store. there’s always an app This description should be enough to understand the gist of what comes below, but more basic information can be gathered from the following video if you’re more of a visual learner. This cashierless idea has made a lot of wave in the retailing world over the past two years. And why shouldn’t it? At face value, automating one of the most staff-heavy store operation appears to be a grand idea : when checkout is done automatically, employees may have more time to upsell, pick up online orders and answer customer queries. Furthermore, wages have been rising and stores are having to cope with slim margins, partly due to online shopping; letting go of some staff could sound like a grand idea for a retailer down on its luck. Computer vision could also mean (also a huge plus when looking to reduce “costs”/people), ($34 billion in lost sales worldwide in 2017) and more space available to increase revenue per square meter. automatic inventory less theft Finally, 2019 obliges me to mention that computer vision gives us access to more sweet, data : customers are not only linked to a name and account to track what they buy, but also visually followed around to track what they do NOT buy (what they stare at, what they pick up and put back…). That’d shine a light on 80% of the purchasing process, which until now has been a bit of a black box (unless people were sent around with pencils to follow shoppers around and write down what they witnessed — ). sweet yes, this still happens This all makes for a pretty compelling argument in favour of an Amazon GO-style store if you’re a retailer. However, I hope to prove that this specific technology will work for Amazon ( , anyone?), and no other company. only 3,000 such stores within the next two years SIZE MATTERS What works in small concept stores might (will) not work in larger ones with heavier foot-traffic. Firstly because large crowds have been known to make cameras glitch (as well as the shelves sensors by taking things and putting them back in random places — ), and secondly because large stores mean a wider selection of products; Amazon GOs have about 1,000 items (or SKUs) in stock, while most grocers have around 80,000. animals Most computer visions software have a 98% accuracy over a couple thousand of items. That means that if 20% of a store’s selection is picked up on any given day in an Amazon GO, there are about 4 mistakes per day per store. Using the same logic, there’d be 320 mistakes per store per day if supermarkets were to implement the solution as it is. That’s 320 clients per day that are more likely to switch to another shop (it’s a fluid industry), which is not great for any store, big or small. And that’s not even taking into account the fact that mistakes are exponential for computer vision algorithms. There are simply too many items that look too similar in large store : even I can’t see the difference between an 80g and a 120g pack of chips. While Amazon made sure it’s offering is easily identifiable, Walmart will never be able to do so on such a large scale. THE ENVIRONMENT MATTERS Computer vision relies on packaging to identify products. Specifically, a mix of printed shapes to make recognition easier. However, I seem to recall that retailers are currently bending over backwards to reduce packaging, and rightly so ( ). save the turtle, y’all Innovation is great, but it does not exist in a vacuum Furthermore, a lot of products cannot be packaged in such ways, such as loose fruits, or deli food, further complicating the matter for grocers. Finally, we would also have to remove all soft fabric from the equation (too flowy-floppy), which rules out fashion stores from using this specific mix of technology. RETROGRADING MATTERS Most retailers simply do not have the money to rebuild a store from scratch. That means retrograding whatever space they have to fit a new process. In the case of installing computer vision cameras and smart shelves, this would mean : Buying enough cameras to cover the whole store and destroying the existing ceiling to rebuild one that can take the weight of that amount of hardware.For cameras to see everything, there can be nothing obscuring their view. That means shopping carts become an inconvenience, as do marketing furniture appreciated by manufacturers to advertise their wares. Goodbye sweet promos.Investing in brighter lights to make “seeing” easier.Investing in new AC systems : so many cameras will create a lot of heat.Invest in new shelves. Even assuming the algorithms are magically free, the original Amazon Go in downtown Seattle required . That’s way too much for an industry working on increasing margins. more than $1 million in hardware alone CASH MATTERS Most countries still rely heavily on cash for a variety of reasons ( ). As such, a variety of laws are likely to be passed in the near future to ensure cash is taken by all stores, lest discrimination becomes rampant. After all, a LOT of people still don’t have a smartphone, and those are the people that might need a grocery store most. That wouldn’t be “stiffing innovation” ( ), it’d be the government doing its job. looking at you, Germany damn Luddites One of the many reasons customers continue to use cash is simply because it gives them a hint of privacy. Amazon claims that it only keeps purchasing and video data just long enough to provide you with an accurate receipt, while only a small subset of the info is retained to further train the algorithms, but anyone who knows how Bezos operates knows that it’s bull : training and improving an algorithm of this nature requires an exponential amount of data. Yes, we’d trade our privacy without a second thought for an Amazon Prime discount ( ), but old-school retailers have a lot less to offer in exchange for abandoning large swathes of privacy. well, a discount and the ability to walk out of the store without having to say “thank you” to a human LABOUR COSTS MATTER Automating tasks means reducing the workforce, and making more profits, right ? Well, only only kind of : firing cashiers is cheap, but hiring data scientists is expensive. A more expensive. And even if a company decides to buy the algorithm instead of creating it, upkeep would still be a major cost, as well as further training and “probability tinkering”. lot That’s what happens when you’re too eager to cut costs. Costs start to cut you. And please do not use this to argue that new technology creates as much jobs as it destroys. There are 3.4 million cashiers in the U.S. We’re not training that many data scientists. Wake up and smell riots. CONCLUSIONS MATTER So. We’re talking about a retail technology that cannot be used for groceries, fashion, or in large stores. But it’s good for snacks, as (Water and gummy-bears being among the best-selling items). . Amazon noticed It will also soon have to take cash Mmhm. Cash for snacks…. Hey I know this one! Basically, Amazon GO is a glorified, incredibly expensive vending machine. Broadly speaking, innovation should either cut costs or drastically benefit the customer ( ). Amazon GO does neither. Sure, the tech will live on because it’s fantastic. But the stores will never materialise for any other brand, unless MASSIVELY scaled, with huge cash backing, the likes of which only Amazon has access to. remember the RFID hype? Of course not, because survivorship bias is a hell of a drug That’s simple economics. Additionally, Jeff Bezos was never one to let economics ruin a good time, especially if a new venture happens to be a great place to put profit from other areas of his business to pay less on taxes. Amazon doesn’t want to make money off the store. It wants data to feed the beast. We just won’t be laughing as much when Amazon is using biometrics instead of a mobile code and app and selling that data to your insurance company. Join a movement This article was originally made for , an online magazine providing in-depth analyses of today’s technological challenges. . The Pourquoi Pas Click here to access it

Stories, News & Mentions about HEATINVERSE

Heatinverse’s Stories on HackerNoon

Heatinverse's News & Mentions