Caulk and foam are used to fill in cracks and gaps that let cold air in around windows. Caulk hardens like glue and foam expands upon application to fill all open areas. The aluminum pole has four telescoping tubes that expand to 65 inches so you can work ...

How to winterize your home

Despite the low price, the Home Depot-exclusive brand has plenty of options available that can help you out with your remodel.

5 Ryobi Power Tools That'll Come In Handy During A Bathroom Remodel

"The theme of the show, the glue that ties it all together, is how my relationship endured me carrying out all of these bucket list stunts." The first bucket list item, "The S--- Hits the Fan," Steve-O describes as "pretty simple and idiotic" but gave him ...

Steve-O's Bucket List

As they should. Recently, this mom posted a video sharing the time her toddler got into her eyelash glue, and it wasn't pretty. Take a look. Mom @jazxfam probably was stunned when she found her daughter had gotten into her makeup. Her 2-year-old ...

Toddler Gets Into Mom’s Eyelash Glue and Uses It for Something Else

On a muggy September evening in Tiger Stadium, LSU football found itself in a precarious situation. The Tigers’ unstoppable offense was stalling.

How Andre' Sam went from FCS walk-on to the glue of LSU football's secondary

TikTok user @theartge recently showed off an easy and cheap DIY for creating a hummingbird feeder using only some everyday materials, including a plastic water bottle, a plastic storage dish, waterproof glue, and some twine. The result is a bare-bones ...

The Easy DIY Hummingbird Feeder That Refills Itself

Twitter/@satishacharyaSatish Acharya too refers to the iPhone hacking controversy, using metaphors to depict the ‘Apple’ devices that were hacked, as well as allegations of snooping levelled against the government by Opposition leaders,

Hello, Siri ft. ‘state-sponsored’ snooping & the glue that binds political funding with secrecy

The Trojans haven’t had a classic ‘Glue Guy’ in recent years, but Rodman should fit the bill,” Rothstein wrote. “The son of former NBA star Dennis Rodman, DJ Rodman h

DJ Rodman earns praise from college basketball insider

To help us gain confidence and banish our fears, we asked our beauty expert to explain how easy false eyelashes are to use.

Afraid to put on false lashes yourself? Our beauty expert explains how easy false eyelashes are to u

Take some sawdust mixed with wood glue, and you have the perfect wood filler replacement. Utilizing sawdust from the same style of wood being treated will make color-matching stains so much simpler. Spills in the garage or a workshop are inevitable.

12 Genius Uses for Sawdust That You Probably Didn’t Know

Glue

glue

The United States v Meta Platforms Court Filing October 24, 2023 is part of . You can jump to any part in this filing . This is part 13 of 100. HackerNoon’s Legal PDF Series here 3. Meta designs and deploys features to capture young users’ attention and prolong their time on its Social Media Platforms. 86. Acquiring young users helps secure Meta’s profit stream over time. By capturing users’ attention and engagement when they are young, Meta ensures future engagement and monetization as those young users grow up. 87. Meta thus develops and implements features to attract young users and keep them engaged on its Social Media Platforms for as long as possible. These features include: engagement-based (as opposed to chronological) feeds; infinite scroll; push notifications; ephemeral content; and video-based content. 88. Meta had originally displayed content on a user’s “Feed” chronologically, i.e., in the order the content was posted by people the user elected to follow. Meta moved from chronological Feeds to engagement-based Feeds in 2009 (for Facebook) and 2016 (for Instagram). 89. The engagement-based Feed is different and alters the users’ experience. It algorithmically presents material to users based on several engagement components: posts with more “Likes,” comments, and other indicia of user engagement are displayed to users first. 90. This change was designed to prioritize material most likely to engage users for longer periods of time. 91. In the fall of 2016, Instagram debuted its infinite scroll system. 92. Infinite scroll is characterized by the partial display of additional content at the bottom of the user’s screen, such that the user is typically unable to look at a single post in isolation (without seeing the top portion of the next post in their Feed). 93. The “teasing” of yet-to-be-viewed content continues indefinitely; as the user scrolls down the Feed, new content is automatically loaded and “teased.” 94. This “teasing” feature is intended to keep young users of the Platform engaged and continuing to scroll to the new content. 95. In April 2015, Meta introduced a variety of “push notifications” to Instagram. Push notifications are auditory and visual cues to alert users when accounts they follow add new content. 96. Push notifications allowed Instagram to draw its users back to the Platform at any time of day. [Redacted] 97. Meta also sought to increase engagement through making certain content available to users only temporarily—with notifications and visual design cues indicating that the content would soon disappear forever (ephemeral content). 98. Ephemeral content leads young users to more frequently open Meta’s Social Media Platforms so they do not “miss out” on any new content. This phenomenon is called “Fear of Missing Out,” or “FOMO.” Meta designed ephemeral content features in its Social Media Platforms to induce this sense of FOMO in young users. 99. For example, on August 2, 2016, Meta introduced a feature to Instagram designed to show images and narratives for only a short amount of time before disappearing, known as the “Stories” feature. Meta released a similar feature to Facebook in 2017. 100-101. [Redacted] 102. Another example is “Live,” which gives users the ability to livestream videos to followers or the public. 103. Meta launched Facebook Live on a limited basis to celebrities and other highprofile users in August 2015, with the feature being available to all users by April 2016. Instagram soon followed in November 2016. 104. Live allows users to create video content in real time that their followers can watch and react to, often called “going Live.” 105. When an account goes Live, the Instagram Platform sends out a notification. 106. [Redacted] 107. In addition to video-streaming offered through the Live feature, Meta has also designed and implemented several video features, including “IGTV,” “Instagram Video,” and ultimately “Reels.”[7] As with prior features, Meta focused on teen engagement with these video features. 108. [Redacted] 109. In 2020, when Meta introduced its short-form video feature, “Reels,” to the U.S. market on Instagram, [Redacted] Reels were made available on Facebook in September 2021. 110. Reels are algorithmically presented to users based on a number of factors, including the user’s activity, the popularity of the content, and the viewer’s connection to the creator. 111. Reels display metrics such as Like counts, comments, and views in the video itself, which reduces the need for the user to navigate away from the video. 112-116. [Redacted] [7] IGTV was revamped in October 2021 (in a shift to Instagram Video), and ultimately removed completely from the Platform in March 2022. Reels was merged with and superseded “Instagram Video” in June 2022. Continue Reading . Here About HackerNoon Legal PDF Series: We bring you the most important technical and insightful public domain court case filings. This court case 4:23-cv-05448 retrieved on October 25, 2023, from is part of the public domain. The court-created documents are works of the federal government, and under copyright law, are automatically placed in the public domain and may be shared without legal restriction. Washingtonpost.com

Meta Intentionally Deploys Features To Keep Young Users Glued to Their Phones

When the whole world is running towards a cliff, he who is running in the opposite direction appears to have lost his mind - C S Lewis The problem is not our smartphones or the internet, which actually can be put into many other purposes, even if they are used for mass behavior modification these days. The problem is the feed algorithms and the business model used by the platforms that use these feed algorithms to get the users glued into their online environments. People have unknowingly become subjects for their mass behavior tests, for which they are being monitored by these algorithms all the time. This business model, which targets ads based on behavior and shows the feed to increase the online activity controlled by secret feed algorithms, is the root problem our society has to battle now. These social media platforms have become the go-to place for manipulators when they need to tweak the behavior of the masses or when they have to turn the tide of people towards them. The effects of these can be seen in present-day politics, business etc. You do not need to give up the internet or give up your smart devices to have full control over your thoughts, but just give up those platforms that use these constantly monitoring, behavior modifying algorithms till these platforms come up with some new innovative business model other than earning through stealing our attention. Feed algorithms are designed so that people spend more time on these platforms without being aware and make millions of revenue from them. These algorithms constantly evolve to increase the usage time of people using the platform by infusing a sense of satisfaction through rewards (likes, engagement etc.) or by infusing a sense of hatred. The program's ability to tweak the behavior and mentality of people who have accounts on these platforms has led to these tools being used for mass manipulation of the public. Primarily they have been using matters related to religion, culture, ethnicity etc., to create a sense of hatred, fear and dilemma among the public. These platforms cleverly hide the fact that they are being used as a collection of mass user data by saying that they are actually evolving how humans communicate. But the fact is that these platforms are doing more harm than good by using such habit-tweaking algorithms. That is, it is being used for other things than staying connected with friends and communicating. People use social media because it is addictive, but they treat it as a medium which induces pleasure. It is actually the dopamine hits one gets while using these platforms because of the features that grab hold of the tribal behavior and mentality of the human mind. People often use these platforms every now and then when they get free time, similar to a smoker searching for cigarettes. These platforms sometimes create a sense of mob mentality by isolating one person's experience from another. This is true because one person's feed is entirely different from another as the feed is shown after collecting their data and interests. These algorithms are most efficient in creating a different space for each person showing each their own feed, so in a way, they isolate them from the rest of the users. Also, these contents are so filtered that they will either be one which goes well along with our thoughts while at times they show us something that contradicts our opinion. This is how they get into human psychology and grab our attention. We judge one another without knowing their real-life scenarios and what they are going through. Knowing these things as a human is important to respect and empathise with others. In this way, it has degraded the core human values of social cooperation and empathy. It is also important to keep in mind whether we are being dominated by our negative self or the negative side of our character when interacting with others. As these algorithms are experts at hacking into our minds and exposing our negative side, it is important not to lose our character, which, when lost, impacts most parts of our life. I may not be the one who is best suited to tell you what is best for you. But be cautious and act wisely when you are dealing with feed algorithms. Originally published . here

How Feed Algorithms Keep Us Glued to Our Screens 

Many modern marketing approaches move in tandem with technological advances, utilizing up-to-date tools to keep up with the growing use of the internet. These tools are used collectively to grow audiences by monitoring, testing, and iterating marketing strategies. Growth marketing consists of various elements including CRO (Conversion Rate Optimisation), SEO (Search Engine Optimisation), UX/ UI (User Experience/ User Interface) design, and analytics; but allow me to hone in on one practical, creative element underpinning all of these elements: Copywriting. The Lifecycle of the Click When executed correctly, these methods work harmoniously; feeding and blending into one another. Actions or ‘clicks’ will be visually guided by the use of effective design, then, those clicks will be monitored and revised using site analytic techniques and methods. But, no one would ever take any action if they don’t understand why they should, which is where clear, concise copy comes into play. What is Copywriting Sitting somewhere in between behavioral science and art, copywriting is the process of composing persuasive text to convince readers to take some form of action; whether it be signing up to a newsletter, making a donation, or making a purchase. Why It’s Important From a business perspective, it’s used to generate more leads, hence more sales. However, there’s also a duty to promote products harnessing potential to ensure proper usage in its target community. For instance, a ground-breaking product may get developed but never have the chance to enter the larger market because it was not accurately depicted, promoted, or described. A Few Rules for Writing Effective Copy: Rule no. 1 Know Your Audience A website for a veterinary clinic will have different copy from a website for a theme park. Determining the correct (Tone Of Voice) should be the first step in producing good copy. The copy should be in line with the tone of the product/ service for the site: exhilarating and joyful copy for the Theme Park, comforting and reassuring copy for the Veterinary Clinic. The TOV proves to the reader they’re on the right track for their search from first glance, keeping them engaged to continue reading. TOV Rule no. 2 Clarity Your audience should always understand why the text they are reading is useful for them. Do not fill your sentences with unnecessary information, only include what they need to know and, more importantly, why they need to know this information. For Short Form copy (headlines, sub-headlines, social media posts) this will be a matter of words, for Long Form Copy (blog posts, press releases, technical analyses) this will be a matter of words in the sentence and sentences in the paragraph. Rule no. 3 Brevity Be brief. Rule no. 4 Honesty Do not lie to your audience. Not only may this result in legal troubles (depending on the severity of the false message) but it will irritate the reader and build a bad, unreliable reputation around your company, costing you a.) a potential customer and b.) a return customer/ return visitor. You must always maintain a good rapport with your audience. Rule no. 5 Editing Edit. Then edit some more. Copywriting is a creative and destructive process, you should trim the text of any unnecessary information by referencing and iterating the other rules until you get to a point where you’re happy with the copy, or better yet- until you’ve convinced yourself that you’re happy with the copy. How Copywriting Resonates with Other Growth Marketing Elements: CRO Conversion Rate Optimisation is monitoring how many people visit your site or make an action. If your copy is clear, the visitor understands the product to a level which is substantial enough for them to make a decision on an action. One way of doing this is by acutely summarising your product in a headline. People do not dwell on sites unless they are captivated at first glance. You should write headlines as if it is the only information that is available to the reader about your product, aiming to secure an action straight off the bat. Honest copy instills the customer with a sense of validation, reassuring them that, in the future, your product will continue to deliver accurately. It also directly affects your analytics, good input = good output. Therefore your copy must be true to the word. This is particularly important for early stage products. For example, do not make false promises: “Sign up to receive access to our Beta” and then not provide such access. This will corrupt the data going into your analytics because the customers are recorded as being interested in your product on the pretence of a deliverable. Would they have signed up if the Beta was not on offer? You’ll never know, and now your projections for future analyses are stunted. SEO Search Engine Optimisation is a method which improves quality and quantity of network traffic to a website from search engines; targeting natural, organic results. SEO writing involves choosing keywords to include in your text and other places on the site (meta tags, titles, etc.) for the search engine to scan and flag them for relevant searches. Unlike writing copy for short form content like a twitter post, choosing SEO keywords is less creatively liberal. It’s a reverse engineering process, logically choosing keywords which highlight your text as briefly and effectively as possible will be most advantageous in ranking your page higher up in the results list. UX/ UI By combining captivating copy and eye-catching design, your site will increase the retention time of visitors, thereby increasing the likelihood of an action being taken. The tone of voice used in the copy should match the design choices of the website. Using the Theme Park and Veterinary clinic example again; bright and warm colours along with exhilarating and joyful copy being used for the theme park website indicate to the visitor that they’re in the right place to find thrilling rides and amusement, and not the place for them to bring their dog with an upset stomach. Entering a new site can be dis-orientating, especially when the site is text-heavy. Creating shrewd prompts for the user to easily navigate across the site will increase accessibility: this can vary from choosing appropriate page names in the nav bar to the choice of text for additional links on pages. A/B Testing A/B testing is used in growth marketing to determine which version (A: the control version or B: the variable version) of the site produces better results. When it comes to A/B testing, the predominant changes to be made will be to the written elements of the site, after all, these are the prompts for actions to occur. This may include adding names to email subject lines or tweaking headlines and headers to see which perform better in the testing variable version. In fact, A/B testing for online marketing was inspired by the principles found in direct response marketing popularised in the early 20th century. Transcending the Digital Threshold Unlike the other online marketing elements, the effects of copywriting can seep into the physical world. Providing clear, concise copy consistently across all mediums of your product will generate public buzz through word of mouth. The rising concerns with privacy surrounds targeted ads with an invasive nature, associating online marketing’s big data approaches with a negative connotation. When hearing a recommendation from a friend or a co-worker, it feels much more genuine than having an ad hurled at you. This is because targeted ads are synthetically personalised by a third party using a third party tool, something which is widely known by the public. Whereas, hearing a recommendation from a real person is a genuine personal exchange because they know you on an individual level. Writing copy which accurately depicts the product will increase the likelihood of a recommendation. If the reader can effortlessly understand the benefits and use cases of your product from your promotions, they’ll be able to recite that information effortlessly to others. Don’t just write copy that sells, write copy that sells selling. Butterfly Effect At its core, copywriting is simply about communicating. When it comes to selling a product, choosing what you communicate will invoke different types of actions. These actions are what drive the analytics modern marketing is heavily based around; picking what you say, how you say it and when you say it will steer the market which you’re analysing in different directions, so pick wisely.

Copywriting: Modern Marketing's Glue

Operating under a shared reality is a competitive advantage, but most teams share state poorly. Let’s talk about glueing brains together! Computers and people both have a “state” In computer systems, state is information that is remembered between interactions. A is one that keeps track of things that have happened before. Databases are where we typically store state, and we try to design our services so they don’t keep track of state themselves, but keep it in a central place. stateful service People, as autonomous beings, require state. The way our thinking works literally requires it. So one of the great challenges of all organizations is distributing a shared understanding of reality: the organization’s challenges, goals, and activities. You don’t copy state, you serialize it With computer systems, and with people, you can’t just copy state around. I can’t clone my brain, or even a part of my brain, and give it to you for you to understand perfectly what I’m thinking. So in computer systems, we serialize information to put it in a format that can be transmitted between machines. Human communication is also serialized. We have to put what is in our minds into words or writing to share it with others. This is necessarily imperfect. It is actually impossible for us to express our internal state to each other, so we have to choose what to serialize, and create a facsimile of what we have in our minds. Human serialization is lossy, too Our serialization is lossy — people listen poorly or use pre-existing state and biases as they listen. And we similarly are poor at serializing our thoughts to give to other people. The protocols we use for communication are ill-defined and ambiguous. And just like computer systems, they require a lot of processing power to transfer even simple messages back and forth. Errors compound the more people you’re dealing with This is hard enough with two humans. But as we increase the number of people involved in any group of humans that need a common understanding of something, you multiply the number of people involved. Each is deserializing that information in a different way. What you’ll often find is that people use error-correction algorithms to verify the messages we hear. After a meeting, you’ll talk over what you heard and double-check your understanding. And then the two of you will try and figure out what you each thought about what you heard. One of the reasons one on one conversations can be inadequate in a remote setting is that when you’re trying to get ten people on the same page about something, and the state is changing as you problem-solve the situation, it’s impossible for those ten people to all have the same understanding of the problem, or proliferating and evolving solutions. In-person teams share state more easily It is easier for in-person teams to “share state”. When you sit next to someone, you are exposed to the same information, and it’s easier to build a shared understanding. This is a prime advantage of colocated teams, working in the same time zone, on the same project. Distributed teams often struggle with sharing state On distributed teams, we have to take extra care to share state. I’ve learned this the hard way — we have to be incredibly explicit in our communication with each other. On distributed teams, it feels like things are the same, but the variance in deserializing information is much higher, so it requires a lot more explicit communication. One particularly bad example of this was when I was working at a company preparing an important project for our user conference. We got two months from the release and found out the engineers thought we were delivering “something” at the conference, even though the leadership had been talking about a GA release for months! When leaders don’t share state, the results are devastating One of the most common “state” problems on engineering teams is when the and product manager aren’t sharing state. They may each have their own version of the project plans. They might each have different ideas of what is being done or what’s important. engineering manager How to merge squishy brains together! There are a few solutions to sharing state. Be explicit and build trust One is to check in frequently and have a lot of explicit communication. The more trust you have with someone, the easier it is to share state because your serialization protocols are better tuned for each other. Use writing to share state Another solution to sharing state is to emphasize writing. When we write something down and collaborate around that shared document, we are all participating more closely in a shared version of reality. While we may deserialize differently, we’re all interacting with the same “database” of information, and the changes are something we all participate in. Writing is less transitory than verbal communication, and it is more precise. I believe it’s one of the key skills for a successful remote company to master. I would pay to make Slack MORE transitory (all messages disappear after a day) because people could rely less on being able to look up previous conversations. Chat isn’t a shared document, because usually, the people involved aren’t starting from a shared state. That’s why chat is effective for solving simple problems together, but not complicated ones. I like the pattern of posting links to information in Slack and having conversations and decisions made around documents. And to reply to things with links to where that information is being maintained. more One of the best patterns I’ve seen for accelerating organizational leadership work is to write down your best thoughts on what the problem is and what to do about it and share it with a group of people. Ask them to make it better. You can go through a couple of rounds of sharing it more broadly, and getting feedback, but you can go through those rounds pretty quickly — a day or two per round. Then just get started! Your plan likely is better than it would have been because you spent the time to write it down. And it’s much better still since your colleagues have improved on it. And everyone’s basically on the same page about the problem and what is to be done about it. In any case, the important thing is to be aware of state, and how you’re ensuring your messages are being communicated. Think of it as a computer system, and it might help! Image by from Willi Heidelbach Pixabay This post is from my (free or paid) newsletter course on engineering leadership

How Shared State can Help Glue your Happy Brains Together

Tech can be an unwelcoming place for women, minorities, and early career folks. We know that. What we don't know is we can do something about it. And yes, it involves documentation. Lack of Women in Leadership (this stat doesn't include career changers). Only 28% of women make it to the c-suite, even though over 60% of women in tech . Women are being professionally shunted in tech, which is a meritocracy failure. 41% of women drop out of tech before they reach the age of 35 expressed interest in a leadership position How "Being Glue" is Holding Women Back and How Documentation Can Help We are not talking enough about the dangers of "being glue." Being glue means doing important but unrecognized work in the office. All of this work moves the needle but does nothing for your annual review. This can include: writing tests mentoring more junior employees event planning writing documentation. Technical documentation describes how your application or API works. Internal documentation explains how your organization function. When you spell out who is responsible for invisible work, you prevent it from falling into women's laps. These tasks can be added and accounted for in sprints. Where internal documentation explicitly assigns the less glamorous work to the team. The payoff? Less unspoken pressure for women to perform underappreciated work. Women can focus more of their time on high prestige projects and start climbing that ladder. Lack of Mentoring for New Developers Many companies are "afraid" of hiring early career devs. The common excuses are: All of their work must be done by senior talent There aren't any senior developers to mentor the early-career developers. The first excuse . I have a hard time believing that all of a company's work must be done by the most senior of engineers. seems improbable The second excuse can be solved by documentation. Figure out the most mission-critical tasks and write them down in an internal knowledge base. Extra points if some of the onboarding material includes screencasts. when content is presented in a video rather than text form. Folks retain more information And finally, documentation aimed towards new developers helps more seasoned programmers too. Beyond the 10x Engineer Instead of looking for 10x developers, tech companies should throw their resources into molding 10x programmers. There are fewer codebase secrets with comprehensive documentation. And finally, when you have systems that empower every developer to be an overachiever, you don't have to hold on to clever bullies. Institutional and technical knowledge is not locked up inside one person's brain. It's equally distributed throughout the team. How to get started Make contributing to documentation part of the performance review. Ensure that there are professional awards tied to keeping the documentation up-to-date. Every month designate one engineer responsible for writing and maintaining the docs. Be sure to name names- make sure you have an accountable team member in charge of docs every month. Onboarding new developers is a great way to "stress test" documentation. Everything that the new team member finds confusing or unclear should go into the documentation. Want another stress test? Encourage the team lead to go on an extended vacation and see what breaks. Be sure to record the gaps of knowledge between the engineering lead and the rest of the team, and be sure to fill in those gaps with documentation. Conclusion Knowledge is power, and this power should be distributed equally. We shouldn't keep a bully around because they are a 10x engineer. We also shouldn't allow one engineer (usually a woman) to shoulder the responsibility of writing the docs to the detriment of their career. Everyone should be maintaining the code base and the knowledge base.

"Being Glue" is Holding Women Back in Tech, but Documentation Can Help

Connect to Salesforce from AWS Glue jobs using the CData JDBC Driver hosted in Amazon S3. AWS Glue is an ETL service from Amazon that allows you to easily prepare and load your data for storage and analytics. Using the PySpark module along with AWS Glue, you can create jobs that work with data over JDBC connectivity, loading the data directly into AWS data stores. In this article, we walk through uploading the CData JDBC Driver for Salesforce into an Amazon S3 bucket and creating and running an AWS Glue job to extract Salesforce data and store it in S3 as a CSV file. Upload the CData JDBC Driver for Salesforce to an Amazon S3 Bucket In order to work with the CData JDBC Driver for Salesforce in AWS Glue, you will need to store it (and any relevant license files) in an Amazon S3 bucket. Open the Amazon S3 Console. Select an existing bucket (or create a new one). Click UploadSelect the JAR file (cdata.jdbc.salesforce.jar) found in the lib directory in the installation location for the driver. Configure the Amazon Glue Job Navigate to ETL -> Jobs from the AWS Glue Console. Click Add Job to create a new Glue job. Fill in the Job properties:Name: Fill in a name for the job, for example: SalesforceGlueJob.IAM Role: Select (or create) an IAM role that has the AWSGlueServiceRole and AmazonS3FullAccess permissions policies. The latter policy is necessary to access both the JDBC Driver and the output destination in Amazon S3.Type: Select "Spark".Glue Version: Select "Spark 2.4, Python 3 (Glue Version 1.0)".This job runs: Select "A new script to be authored by you". Populate the script properties: A name for the script file, for example: GlueSalesforceJDBC Fill in or browse to an S3 bucket. Fill in or browse to an S3 bucket. Expand . For Dependent jars path, fill in or browse to the S3 bucket where you uploaded the JAR file. Be sure to include the name of the JAR file itself in the path, i.e.: s3://mybucket/cdata.jdbc.salesforce.jarClick Next. Here you will have the option to add connection to other AWS endpoints. So, if your Destination is Redshift, MySQL, etc, you can create and use connections to those data sources. Click "Save job and edit script" to create the job. In the editor that opens, write a python script for the job. You can use the sample script (see below) as an example. Script file name: S3 path where the script is stored: Temporary directory: Security configuration, script libraries and job parameters (optional) Sample Glue Script To connect to Salesforce using the CData JDBC driver, you will need to create a JDBC URL, populating the necessary connection properties. Additionally, you will need to set the property in the JDBC URL (unless you are using a Beta driver). You can view the licensing file included in the installation for information on how to set this property. RTK There are several authentication methods available for connecting to Salesforce: Login, OAuth, and SSO. The Login method requires you to have the username, password, and security token of the user. If you do not have access to the username and password or do not wish to require them, you can use OAuth authentication. SSO (single sign-on) can be used by setting the SSOProperties, SSOLoginUrl, and TokenUrl connection properties, which allow you to authenticate to an identity provider. See the "Getting Started" chapter in the help documentation for more information. Built-in Connection String Designer For assistance in constructing the JDBC URL, use the connection string designer built into the Salesforce JDBC Driver. Either double-click the JAR file or execute the JAR file from the command-line. view source java -jar cdata.jdbc.salesforce.jar Fill in the connection properties and copy the connection string to the clipboard. To host the JDBC driver in Amazon S3, you will need a license (full or trial) and a Runtime Key (RTK). For more information on obtaining this license (or a trial), . contact our sales team Below is a sample script that uses the CData JDBC driver with the PySpark and AWSGlue modules to extract Salesforce data and write it to an S3 bucket in CSV format. Make any necessary changes to the script to suit your needs and save the job. view source sys awsglue.transforms * awsglue.utils getResolvedOptions pyspark.context SparkContext awsglue.context GlueContext awsglue.dynamicframe DynamicFrame awsglue.job Job
 
args = getResolvedOptions(sys.argv, [ ])
 
sparkContext = SparkContext()
glueContext = GlueContext(sparkContext)
sparkSession = glueContext.spark_session
 
##Use the CData JDBC driver to read Salesforce data the Account table into a DataFrame
##Note the populated JDBC URL and driver = sparkSession.read.format( ).option( , ).option( , ).option( , ).load()
 
glueJob = Job(glueContext)
glueJob.init(args[ ], args)
 
##Convert DataFrames to AWS Glue import from import from import from import from import from import from import 'JOB_NAME' from class name source_df "jdbc" "url" "jdbc:salesforce:RTK=5246...;User=username;Password=password;SecurityToken=Your_Security_Token;" "dbtable" "Account" "driver" "cdata.jdbc.salesforce.SalesforceDriver" 'JOB_NAME' 's DynamicFrames Object
dynamic_dframe = DynamicFrame.fromDF(source_df, glueContext, "dynamic_df")
 
##Write the DynamicFrame as a file in CSV format to a folder in an S3 bucket.
##It is possible to write to any Amazon data store (SQL Server, Redshift, etc) by using any previously defined connections.
retDatasink4 = glueContext.write_dynamic_frame.from_options(frame = dynamic_dframe, connection_type = "s3", connection_options = {"path": "s3://mybucket/outfiles"}, format = "csv", transformation_ctx = "datasink4")
 
glueJob.commit() Run the Glue Job With the script written, we are ready to run the Glue job. Click Run Job and wait for the extract/load to complete. You can view the status of the job from the Jobs page in the AWS Glue Console. Once the Job has succeeded, you will have a CSV file in your S3 bucket with data from the Salesforce Account table. Using the CData JDBC Driver for Salesforce in AWS Glue, you can easily create ETL jobs for Salesforce data, whether writing the data to an S3 bucket or loading it into any other AWS data store.

How to Connect to Salesforce Data in AWS Glue Jobs Using JDBC

This Tutorial shows how to generate a billing for AWS Glue ETL Job usage (simplified and assumed problem details), with the goal of learning to: Unittest in PySpark Writing Basic Function Definition and Conversion to UDF Repository: https://gitlab.com/suekto.andreas/gluebilling Business Problem This tutorial shall build a simplified problem of generating billing reports for usage of AWS Glue ETL Job. (Disclaimer: all details here are merely hypothetical and mixed with assumption by author) Let’s say as an input data is the logs records of job id being run, the start time in RFC3339, the end time in RFC3339, and the DPU it used. The price of usage is 0.44USD per DPU-Hour, billed per second, with a 10-minute minimum for each ETL job, while crawler cost 0.20USD per DPU-Hour, billed per second with a 200s minimum for each run (once again these numbers are made up for the purpose of learning.) Now we are going to calculate the daily billing summary for our AWS Glue ETL usage. Prerequisite Install JDK 1.8, and setup the JAVA_HOME into the corresponding location (I personally using Mac, and following this and — and JAVA_HOME would be /Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/) link download-link Python 2.7.x Python Coverage, unittest, and PySpark packages (Preferably installed under virtualenv) Actually for this project I am using a bash-script builder to establish the basis of the project, it still in beta state, and this tutorial is being used to see how comfortable I am with that auto script builder. Similar result can be achieved by manually following this articles: https://hackernoon.com/setting-up-python-dev-in-vs-code-e84f01c1f64b https://medium.com/@suekto.andreas/automate-documentation-in-python-925c38eae69f Activities To do the above we would go along with the following pseudocode: Load into PySpark DataFrame Calculate the duration in seconds out of the from and to unix timestamp Calculate the fee per records 001 — Calculate Duration (+ unit test) First let’s build the calculate duration function. The following is the module directory structure that we are going to use : module gluebilling — billing.py All files *.py are started with empty files, the __init__.py is to indicate that we define gluebilling as a python module. let’s start with writing the function skeleton in billing.py. """Process records of ETL Job usage into the billing of fee"""from datetime import datetime as dt def calculate_duration(from_timestamp, to_timestamp):"""Returns duration in second between two timereturn 0 Based on the skeleton, we already have a clearer though of how it should be called and what kind of value shall it returns, now let us create the unit test for this function, to define in more details the behaviour of it. This is written in billing_utest.py """Unit Testing for Glue Billing Project"""import unittest import gluebilling.billing as billing class CalculateDurationTest(unittest.TestCase):"""Test Cases for Glue Billing Unit Testing""" def test\_positive\_duration(self):  
    """Test successfully calculate duration  
    between 2 unix timestamp string"""  
    duration = billing.calculate\_duration(  
        "1535824800", "1535835600")  
    self.assertEqual(duration, 10800)

def test\_negative\_duration(self):  
    """Test successfully generate negative number"""  
    duration = billing.calculate\_duration(  
        "1535835600", "1535824800")  
    self.assertEqual(duration, -10800) In writing a unit testing, we import the unittest module, and the module of which we want to test (gluebilling.billing) module. Next we define the class to host the test cases (CalculateDurationTest) extending the base class (unittest.TestCase) Afterward within the CalculateDurationTest, we define the list of test cases in a object method format prefix with `test_`. We put in the input arguments, execute the function we want to test, and finally check the result using the assertEqual function coming from unittest.TestCase. if we run the unittest now it should be failing $ coverage run --source=gluebilling -m unittest discover -p "*utest*.py" -f -s gluebilling/ coverage with unittest result Now after having the red state, let us start implementing the function """Process records of ETL Job usage into the billing of fee"""from datetime import datetime as dt def calculate_duration(from_timestamp, to_timestamp):"""Returns duration in second between two timeprovided in unix timestamp"""from_dt = dt.fromtimestamp(float(from_timestamp))to_dt = dt.fromtimestamp(float(to_timestamp)) time\_delta = to\_dt - from\_dt  
return time\_delta.total\_seconds() Now we shall have all test cases in green state calculate_duration implementation completed ! Noticed that the screenshot above is a development environment setup with automated run of testing and coverage calculation, based on https://hackernoon.com/setting-up-python-dev-in-vs-code-e84f01c1f64b 002 — Calculate Fee (+ unit test) Following up the same technique above we are adding the calculate fee function as below : in billing.py """Process records of ETL Job usage into the billing of fee"""from datetime import datetime as dtfrom decimal import Decimal ... def calculate_fee(duration_in_second, dpu_num,minimum_duration, fee_dpu_hour):"""Returns a decimal of the fee incurred in USD,quantized into 8 digit behind comma""" charged\_duration = duration\_in\_second  
if charged\_duration < minimum\_duration:  
    charged\_duration = minimum\_duration

fee = charged\_duration \* dpu\_num \* Decimal(fee\_dpu\_hour) / 3600  
return fee.quantize(Decimal('0.00000000')) in billing_utest.py we shall add another class to host test cases for calculate_fee. """Unit Testing for Glue Billing Project"""import unittestfrom decimal import Decimal import gluebilling.billing as billing ... class CalculateFeeTest(unittest.TestCase):"""Unit Test for calculate_fee function""" def test_more_than_10_min(self):"""When usage is more than 10 min"""fee = billing.calculate_fee(800, 3, 600, "0.44")self.assertEqual(fee, Decimal("0.29333333")) Noticed that the dpu_hour value is set as instead of float, as this is the more accurate result of calculation if we further convert it into Decimal type. string “0.44” The reason why I separate the test cases for the 2 functions into different classes because the snake case requires the length of function capped into 30 characters, so to maintain readability we divide it into different classes for each function to test. pylint C0103 The coverage test result after implementing calculate_fee, notice that the coverage can be done better, it is left for the reader to exercise (see the red colour bar) 003 — PySpark Billing Calculation (+ functional test) This article is using similar basic concept from , the differences would be in the details where we focus our setup to be completely standalone (this shall be reflected in how we initialised the Spark Session, and how we prepare the test data) tutorial from David Illes Here is the version that we are going to use, we store it as pyspark_htest.py """PySparkTest is base class to do functional testing on PySpark"""import unittestimport loggingimport osfrom pyspark.sql import SparkSessionfrom pandas.testing import assert_frame_equal class PySparkTest(unittest.TestCase):"""BaseClass which setup local PySpark""" @classmethod  
def suppress\_py4j\_logging(cls):  
    """Supress the logging level into WARN and above"""  
    logger = logging.getLogger('py4j')  
    logger.setLevel(logging.WARN)

@classmethod  
def create\_testing\_pyspark\_session(cls):  
    """Returns SparkSession connecting to local context  
    the extrajava session is to generate   
    the metastore\_db and derby.log into .tmp/ directory"""  
    tmp\_dir = os.path.abspath(".tmp/")  
    return (SparkSession.builder  
            .master('local\[1\]')  
            .appName('local-testing-pyspark-context')  
            .config("spark.driver.extraJavaOptions",  
                    "-Dderby.system.home="+tmp\_dir)  
            .config("spark.sql.warehouse.dir", tmp\_dir)  
            .getOrCreate())

@classmethod  
def setUpClass(cls):  
    """Setup the Spark"""  
    cls.suppress\_py4j\_logging()  
    cls.spark = cls.create\_testing\_pyspark\_session()

@classmethod  
def tearDownClass(cls):  
    """Clean up the Class"""  
    cls.spark.stop()

@classmethod  
def assert\_dataframe\_equal(cls, actual, expected, keycolumns):  
    """Helper function to compare small dataframe"""  
    exp\_pd = expected.toPandas().sort\_values(  
        by=keycolumns  
    ).reset\_index(drop=True)  
      
    act\_pd = actual.toPandas().sort\_values(  
        by=keycolumns  
    ).reset\_index(drop=True)  
    return assert\_frame\_equal(act\_pd, exp\_pd) Noticed that this base class providing many useful class methods with the goal of : suppressing any logging into WARN only (PySpark using py4j for logging) building Spark Session in localhost with 1 core, and setting up the temporary metastore_db to be tidied up stored in .tmp/ directory, alongside with the derby.log (Just so that our workspace is tidy and clean) — create_testing_pyspark_session The setUpClass and tearDownClass is automatically called once. assert_dataframe_equal — receiving PySpark Dataframe, and then converting them all into Pandas, sorting it by the keys (because PySpark results does not maintain the order) then we use Pandas testing to compare the two dataframe. Let’s create the skeleton of the function (billing.py) alongside with the expected Schema definition of our input records and targetted output, the billing records. def get_usage_record_schema():"""Retruns StructType containing the Input UsageData Expected Schema"""return StructType([StructField("job_id", StringType(), False),StructField("type", StringType(), False),StructField("dpu", IntegerType(), False),StructField("from_unix_timestamp", StringType(), False),StructField("to_unix_timestamp", StringType(), False)]) def get_pricing_schema():"""Retruns StructType containing the InputPricing Data Expected Schema"""return StructType([StructField("type", StringType(), False),StructField("dpu_hour", StringType(), False),StructField("minimum_duration", IntegerType(), False)]) def get_billing_schema():"""Retruns StructType containing the Billing Schema"""return StructType([StructField("job_id", StringType(), False),StructField("type", StringType(), False),StructField("dpu", IntegerType(), False),StructField("from_unix_timestamp", StringType(), False),StructField("to_unix_timestamp", StringType(), False),StructField("dpu_hour", StringType(), False),StructField("minimum_duration", IntegerType(), False),StructField("duration", IntegerType(), False),StructField("fee", DecimalType(20, 8), False),]) def generate_billing(usage_df, pricing_df):"""Returns DataFrame of Fee from a DataFrame of Usage Records"""return None Next we go into the billing_ftest.py to prepare for our functional testing. """Functional Testing for Glue Billing Project"""from decimal import Decimalfrom pyspark.sql import Row, SQLContext import gluebilling.billing as billingimport gluebilling.pyspark_htest as pysparktest class GenerateBillingTest(pysparktest.PySparkTest):"""Test Cases for Generate Billing""" def generate\_usage\_data\_001(self):  
    """Generate usage data for testing it is a record of  
    AWS Glue ETL usage"""  
    rdd = self.spark.sparkContext.parallelize(\[  
        Row("JOB001", "etl", 3, "1535824800", "1535835600"),  
        Row("JOB002", "crawler", 3, "1535824800", "1535824850"),  
        Row("JOB003", "crawler", 3, "1535824800", "1535835600")  
    \])  
    schema = billing.get\_usage\_record\_schema()

    sqlctx = SQLContext(self.spark.sparkContext)  
    return sqlctx.createDataFrame(rdd, schema)

def generate\_pricing\_data\_001(self):  
    """Generate pricing data for testing it is a record of  
    AWS Glue ETL usage"""  
    rdd = self.spark.sparkContext.parallelize(\[  
        Row("etl", "0.44", 600),  
        Row("crawler", "0.20", 200)  
    \])  
    schema = billing.get\_pricing\_schema()

    sqlctx = SQLContext(self.spark.sparkContext)  
    return sqlctx.createDataFrame(rdd, schema)

def generate\_expected\_billing\_001(self):  
    """Generate expected billing"""  
    rdd = self.spark.sparkContext.parallelize(\[  
        Row("JOB001", "etl", 3, "1535824800", "1535835600",      
            "0.44", 600, 10800, Decimal("3.96")),  
        Row("JOB002", "crawler", 3, "1535824800", "1535824850",   
            "0.20", 200, 50, Decimal("0.03333333")),  
        Row("JOB003", "crawler", 3, "1535824800", "1535835600",   
            "0.20", 200, 10800, Decimal("1.80"))  
    \])  
    schema = billing.get\_billing\_schema()

    sqlctx = SQLContext(self.spark.sparkContext)  
    return sqlctx.createDataFrame(rdd, schema)

def test\_with\_set\_001(self):  
    """Using all 001 test data set"""  
    usage\_df = self.generate\_usage\_data\_001()  
    pricing\_df = self.generate\_pricing\_data\_001()  
    expected = self.generate\_expected\_billing\_001()

    actual = billing.generate\_billing(usage\_df, pricing\_df)

    self.assert\_dataframe\_equal(actual, expected, \["job\_id"\]) We prepare our input data in two function:1. generate_usage_data_0012. generate_pricing_data_001The technique being used here is by creating rdd using Row and paralellize method of SparkContext, and then combining with the defined Schema from the main script. We also prepare the expected output data inside billing_ftest.py, in function generate_expected_billing_001, with similar technique as we prepare the input data. The last component of billing_ftest.py is test_with_set_001, which is where the test being executed by combining the generation functions of input, and expected dataframe, and then we execute the main script function generate_billing, finally we do asssertion, by leveraging the helper assert method we define in pyspark_htest.py. Finally let’s complete the function implementation in billing.py. def generate_billing(usage_df, pricing_df):"""Returns DataFrame of Fee from a DataFrame of Usage Records""" duration\_udf = udf(calculate\_duration, IntegerType())

join\_data\_df = usage\_df.join(  
    pricing\_df,  
    usage\_df.type == pricing\_df.type  
).select(  
    usage\_df.job\_id, usage\_df.type,  
    usage\_df.dpu, usage\_df.from\_unix\_timestamp,  
    usage\_df.to\_unix\_timestamp,  
    pricing\_df.dpu\_hour, pricing\_df.minimum\_duration,  
    duration\_udf(  
        usage\_df.from\_unix\_timestamp,  
        usage\_df.to\_unix\_timestamp).alias("duration")  
)

fee\_udf = udf(calculate\_fee, DecimalType(20, 8))

billing\_df = join\_data\_df.select(  
    "job\_id", "type", "dpu", "from\_unix\_timestamp",  
    "to\_unix\_timestamp", "dpu\_hour", "minimum\_duration",      
    "duration",  
    fee\_udf(  
        join\_data\_df.duration, join\_data\_df.dpu,  
        join\_data\_df.minimum\_duration, join\_data\_df.dpu\_hour  
    ).alias("fee")  
)

return billing\_df We are wrapping our calculate_fee and calculate_duration function into udf, as this is the the type that can be passed into pyspark. The 1st argument is the function to be wrapped, while the 2nd argument is the expected return type. Then we use this in the SELECT part of the PySpark SQL DataFrame to generate the 2 new columns duration and fee accordingly. Conclusion That’s it now we have implemented the functional test, I differentiate this with the calculate_fee and calculate_duration because of the speed on how this test being executed, it requires several seconds to start up the pyspark hence its worthed to be group differently. This open up options for us to filter out what kind of test do we want to run on save (in case we are automating the development experience)

Tutorial : AWS Glue Billing report with PySpark with Unittest

Nir’s Note: This guest post is an excerpt from the new book Invisible Influence: The Hidden Factors that Shape Behavior , written by my friend and Wharton School professor, Jonah Berger . Being different, the notion goes, is the route to success. Think different was even Apple’s motto for a period. And Apple is often held up as a poster child of the benefits of this ethos. Conventional wisdom suggests that products like the iPhone and Macintosh succeeded because they were different from the rest. Steve Jobs was a visionary because he thought different from everyone else. There’s only one problem with this advice. It’s wrong. While the success of companies like Apple and Google is often attributed to them “thinking differently,” different ideas just as often fail miserably (remember the Segway, the Newton, or Google Glass?). Further, Apple and Google’s biggest successes actually came in areas where they were followers rather than leaders. Apple didn’t introduce the first smartphone, IBM did. Yahoo and AltaVista were doing search way before Google was. Research finds that almost 50% of market pioneers fail, and later entrants, or organizations that don’t enter a market first often end up being more successful. So if being different doesn’t explain success, what does? In the 1800s, a new innovation was introduced that had the potential to radically change transportation. At the time, most people traveled via horse and buggy. This was fine for shorter distances, but as cities grew, the method proved restrictive. It was slow, expensive, and even dangerous. The engine (horse) had a mind of its own, and fatality rates in large metropolises like Chicago were seven times what they are for cars today. Gasoline powered vehicles promised a solution. These early automobiles could go farther, faster, and even cut down on manure, which at the time was threatening to suffocate many major cities. But getting people to adopt what we now think of as cars required a huge mind shift. Horses (and donkeys) had been the primary transportation method for thousands of years. While there were many drawbacks to this method, people were comfortable with it. They knew what to expect. Automobiles were completely new. They required different fuel to run, different skills to drive, and different know-how to fix. These changes required some getting used to. The first time people saw a carriage roll down the street without a horse in front, they were shocked. Rural Americans viewed this “Devil’s Wagon” as symbolizing the decadence of the city, and introduced restrictive laws to block its intrusion. Horses, skittish to begin with, were spooked by these loud, rambling horseless carriages and prone to run away, taking their passengers careening with them. In 1899, Uriah Smith came up with a solution. The issue he realized, was psychological more than functional. Even if automobiles performed better, a horseless carriage was still hard to conceptualize. Smith’s Horsey Horseless So Smith proposed something to make horses, and people, more comfortable. Named the Horsey Horseless, it involved taking a life-size replica of a horse head, down to the shoulders, and attaching it to the front of a carriage. The buggy had the appearance of a horse-drawn vehicle, and thus horses, and their human riders, would be less likely to be scared when it passed by. The fake head also could be used as a gas tank. It’s easy to laugh at a fake horse head glued to the front of a car. It seems silly, almost comical. But while it might seem ridiculous today, it’s hard to imagine how daunting and unconventional cars were when they were first introduced. So rather than highlighting what made the automobile new and different, Smith did the opposite. He made the novel innovation seem more familiar. Similar rather than different. Smith isn’t alone. Chobani has taken the yogurt market by storm. When they started, so-called Greek Yogurt made up only a tiny sliver of the yogurt market. Less than one quarter of one percent. Now Greek yogurt makes up more than 50% of the market. Chobani alone claims at least half that. It’s tempting to attribute Chobani’s success to them being different from everyone else. But that’s just not the case. Not only weren’t they first to market, when Chobani came on the scene Fage had already been selling Greek Yogurt in the United States for almost a decade. Chobani succeeded not by being different, but by being similar to existing consumer tastes. In Greece, yogurt often came unflavored in large family size containers. But American consumers were used to buying single serving yogurt with fruit already mixed in, so that’s what Chobani offered. They reinvigorated the yogurt market by providing a healthier take on an old favorite (single serving yogurt with fruit already mixed in). Turns out that being different doesn’t drive success, . Offering the right blend of similarity and difference. Successful innovations and ideas aren’t identical to what came before, but they aren’t completely different either. They mix familiarity and novelty, old and new. being optimally distinct does The Toyota Prius succeeded not by going full electric, but making a gas powered car more energy efficient. Highly successful songs blend similar melodies with new lyrics. And high-impact scientific research is often grounded in prior work with a few unusual combinations of new ideas sprinkled in. Sure there is some difference, but there is also a lot of similarity. Successful companies, products, and ideas, then, are a bit like Goldilocks and the Three Bears. Goldilocks is always turned off by the extremes. The firm bed is too firm and the soft bed too soft. The hot porridge too hot and the cold porridge too cold. But the middle is just right. The same pattern often occurs with new products, services, and ideas. If something is too different, it requires such a shift in thinking or behavior that it often fails. The Apple Newton, an early predecessor to today’s iPhone, wasn’t just a new device, it was a completely new category. At the time, people had a hard time understanding why they needed it or how it would fit in their lives. The Segway faced similar challenges. Supposed to be a “game changer” in personal transportation, it was so different from anything else that people didn’t know what to do with it. On the other extreme, if something is too similar, it doesn’t provide enough reason to change. If this year’s software is exactly the same as last year’s there’s no reason to upgrade. If a competitor’s product offers the same features at the same price, there’s no reason to switch. But in between and it’s just right. Similar enough to what is already out there to evoke the warm glow of familiarity, but different enough to seem new and not simply derivative of what came before. Distinct, but optimally so. Leveraging this Goldilocks Effect, or optimal distinctiveness, then is particularly important when managing innovation. When launching a new product like the Swiffer, how should it be described? Is it a revolutionary mop? A completely new cleaning category? And what about design? Should seats in driverless cars face forward because that is what people are used to, even if that is no longer required? The same is true when introducing new ideas. Is it better to present a strategy as completely new, unlike anything the company has ever considered before? Or frame it as the logical progression from something being done already? Focus on difference or highlight similarity and difference at the same time? Just like the Horsey Horseless, successfully introducing more radical innovations and ideas often involves making difference feel familiar. When TiVo introduced what we think of today as a digital video recorder, they had a similar challenge to the automobile. The technology was innovative and had the potential to create a completely new market. But tapping that potential required getting consumers to shift their behavior. So to make it easier for consumers to understand the service, and help transition people from passive watchers to active content directors, TiVo designed their device to look like a VCR. A black, rectangle that sat below the TV or above the cable box, just like a regular VCR or DVD player would. Pry open a DVR and a VCR and the guts are completely different. Digital video recorders don’t contain any film, so there was no need for the device to look anything like a VCR. It could have been shaped like a standard desktop computer, colored bright blue, or made into a pyramid. But by using a familiar form, TiVo made people more comfortable adopting this radical innovation. By hiding the technology in something that looked visually familiar, TiVo used similarity to make difference feel more palatable. Many digital actions today visually evoke their analog ancestors. We click on the icon of a floppy disk to save documents and drag digital files to be thrown away in what looks like a waste bin. eReaders have page numbers like physical books. Visual similarity also shows up offline. Digital cameras were designed to resemble film cameras and Edison designed the light bulb to resemble the existing technology of the kerosene lamp. All make the different seem more similar. That’s not to say that difference is always bad. For incremental innovations, or ideas that seem unoriginal, highlighting differentiation helps. When Apple introduced the iMac in 1998, it featured only minor technological improvements. But from a visual standpoint it was radically different. Rather than the same old black or grey box, the iMac was shaped like a gum drop and came in colors like tangerine and strawberry. The design helped make similar technology more optimally distinct, and ultimately more successful. For things that provide only a modest enhancement over current practice, emphasizing difference creates the needed novelty to encourage behavior change. But for things that provide a more marked change, embedding them within, rather than distinguishing them from, existing practice speeds adoption. Too different and it’s unfamiliar, risky, and overly complex. Too similar and its boring, played out, and yesterday’s news. But in between and it’s just right. Optimally distinct. Maybe we could all learn a thing or two from Goldilocks. If you found this post interesting, it would mean a lot to me if you could click on the “claps” icon below to let me know. That would really make my day — thanks! Nir Eyal is the author of Hooked: How to Build Habit-Forming Products and blogs about the psychology of products at NirAndFar.com .For more insights on changing behavior, join his free newsletter and receive a free workbook.

Stories, News & Mentions about GLUE

Glue’s Stories on HackerNoon

Glue's News & Mentions