Posted on

Managing User Focus with :focus-visible

This is going to be the 2nd post in a small series we are doing on form accessibility. If you missed the first post, check out Accessible Forms with Pseudo Classes. In this post we are going to look at :focus-visible and how to use it in your web sites!

Focus Touchpoint

Before we move forward with :focus-visible, let’s revisit how :focus works in your CSS. Focus is the visual indicator that an element is being interacted with via keyboard, mouse, trackpad, or assistive technology. Certain elements are naturally interactive, like links, buttons, and form elements. We want to make sure that our users know where they are and the interactions they are making.

Remember don’t do this in your CSS!

:focus {
  outline: 0;
}

/*** OR ***/

:focus {
  outline: none;
}

When you remove focus, you remove it for EVERYONE! We want to make sure that we are preserving the focus.

If for any reason you do need to remove the focus, make sure there is also fallback :focus styles for your users. That fallback can match your branding colors, but make sure those colors are also accessible. If marketing, design, or branding doesn’t like the default focus ring styles, then it is time to start having conversations and collaborate with them on the best way of adding it back in.

What is focus-visible?

The pseudo class, :focus-visible, is just like our default :focus pseudo class. It gives the user an indicator that something is being focused on the page. The way you write :focus-visible is cut and dry:

:focus-visible {
  /* ... */
}

When using :focus-visible with a specific element, the syntax looks something like this:

.your-element:focus-visible {
  /*...*/
}

The great thing about using :focus-visible is you can make your element stand out, bright and bold! No need to worry about it showing if the element is clicked/tapped. If you choose not to implement the class, the default will be the user agent focus ring which to some is undesirable.

Backstory of focus-visible

Before we had the :focus-visible, the user agent styling would apply :focus to most elements on the page; buttons, links, etc. It would apply an outline or “focus ring” to the focusable element. This was deemed to be ugly, most didn’t like the default focus ring the browser provided. As a result of the focus ring being unfavorable to look at, most authors removed it… without a fallback. Remember, when you remove :focus, it decreases usability and makes the experience inaccessible for keyboard users.

In the current state of the web, the browser no longer visibly indicates focus around various elements when they have focus. The browser instead uses varying heuristics to determine when it would help the user, providing a focus ring in return. According to Khan Academy, a heuristic is, “a technique that guides an algorithm to find good choices.”

What this means is that the browser can detect whether or not the user is interacting with the experience from a keyboard, mouse, or trackpad and based on that input type, it adds or removes the focus ring. The example in this post highlights the input interaction.

In the early days of :focus-visible we were using a polyfill to handle the focus ring created by Alice Boxhall and Brian Kardell, Mozilla also came out with their own pseudo class, :moz-focusring, before the official specification. If you want to learn more about the early days of the focus-ring, check out A11y Casts with Rob Dodson.

Focus Importance

There are plenty of reasons why focus is important in your application. For one, like I stated above, we as ambassadors of the web have to make sure we are providing the best, accessible experience we can. We don’t want any of our users guessing where they are while they are navigation through the experience.

One example that always comes to mind is the Two Blind Brothers website. If you go to the website and click/tap (this works on mobile), the closed eye in the bottom left corner, you will see the eye open and a simulation begins. Both the brothers, Bradford and Bryan Manning, were diagnosed at a young age with Stargardt’s Disease. Stargardt’s disease is a form of macular degeneration of the eye. Over time both brothers will be completely blind. Visit the site and click the eye to see how they see.

If you were in their shoes and you had to navigate through a page, you would want to make sure you knew exactly where you were throughout the whole experience. A focus ring gives you that power.

Image of the home page from the Two Blind Brothers website.

Demo

The demo below shows how :focus-visible works when added to your CSS. The first part of the video shows the experience when navigating through with a mouse the second shows navigating through with just my keyboard. I recorded myself as well to show that I did switch from using my mouse, to my keyboard.

Video showing how the heuristics of the browser works based on input and triggering the focus visible pseudo class.
Video showing how the heuristics of the browser works based on input and triggering the focus visible pseudo class.

The browser is predicting what to do with the focus ring based on my input (keyboard/mouse), and then adding a focus ring to those elements. In this case, when I am navigating through this example with the keyboard, everything receives focus. When using the mouse, only the input gets focus and the buttons don’t. If you remove :focus-visible, the browser will apply the default focus ring.

The code below is applying :focus-visible to the focusable elements.

:focus-visible {
  outline-color: black;
  font-size: 1.2em;
  font-family: serif;
  font-weight: bold;
}

If you want to specify the label or the button to receive :focus-visible just prepend the class with input or button respectively.

button:focus-visible {
  outline-color: black;
  font-size: 1.2em;
  font-family: serif;
  font-weight: bold;
}

/*** OR ***/

input:focus-visible {
  outline-color: black;
  font-size: 1.2em;
  font-family: serif;
  font-weight: bold;
}

Support

If the browser does not support :focus-visible you can have a fall back in place to handle the interaction. The code below is from the MDN Playground. You can use the @supports at-rule or “feature query” to check support. One thing to keep in mind, the rule should be placed at the top of the code or nested inside another group at-rule.

<button class="button with-fallback" type="button">Button with fallback</button>
<button class="button without-fallback" type="button">Button without fallback</button>
.button {
  margin: 10px;
  border: 2px solid darkgray;
  border-radius: 4px;
}

.button:focus-visible {
  /* Draw the focus when :focus-visible is supported */
  outline: 3px solid deepskyblue;
  outline-offset: 3px;
}

@supports not selector(:focus-visible) {
  .button.with-fallback:focus {
    /* Fallback for browsers without :focus-visible support */
    outline: 3px solid deepskyblue;
    outline-offset: 3px;
  }
}

Further Accessibility Concerns

Accessibility concerns to keep in mind when building out your experience:

  • Make sure the colors you choose for your focus indicator, if at all, are still accessible according to the information documented in the WCAG 2.2 Non-text Contrast (Level AA)
  • Cognitive overload can cause a user distress. Make sure to keep styles on varying interactive elements consistent

Browser Support

This browser support data is from Caniuse, which has more detail. A number indicates that browser supports the feature at that version and up.

Desktop

ChromeFirefoxIEEdgeSafari
864*No8615.4

Mobile / Tablet

Android ChromeAndroid FirefoxAndroidiOS Safari
12312412315.4

Managing User Focus with :focus-visible originally published on CSS-Tricks, which is part of the DigitalOcean family. You should get the newsletter.

Posted on

Cilium: The De Facto Kubernetes Networking Layer and Its Exciting Future

Cilium is an eBPF-based project that was originally created by Isovalent, open-sourced in 2015, and has become the center of gravity for cloud-native networking and security. With 700 active contributors and more than 18,000 GitHub stars, Cilium is the second most active project in the CNCF (behind only Kubernetes), where in Q4 2023 it became the first project to graduate in the cloud-native networking category. A week ahead of the KubeCon EU event where Cilium and the recent 1.15 release are expected to be among the most popular topics with attendees, I caught up with Nico Vibert, Senior Staff Technical Engineer at Isovalent, to learn more about why this is just the beginning for the Cilium project.

Q:  Cilium recently became the first CNCF graduating “cloud native networking” project — why do you think Cilium was the right project at the right time in terms of the next-generation networking requirements of cloud-native?

Posted on

How We Achieved a 40x Performance Boost in Metadata Backup and Recovery

JuiceFS achieved a 40x performance boost in metadata backup and recovery through optimizations from v0.15.2 to v1.0 RC2. Key optimizations focused on reducing data processing granularity, minimizing I/O operations, and analyzing time bottlenecks. The overall improvements resulted in a 2300% reduction in dump process runtime and a 4200% decrease in memory usage, while the load process achieved a 230% runtime reduction and a 330% decrease in memory usage.

As an open-source cloud-native distributed file system, JuiceFS supports various metadata storage engines, each with its unique data management format. To facilitate management, JuiceFS introduced the dump command in version 0.15.2, allowing the uniform formatting of all metadata into a JSON file for backup. Additionally, the load command enables the restoration or migration of backups to any metadata storage engine. For details on these commands, see Command Reference. The basic usage is as follows:

Posted on

Create a Registration API in 15 minutes

Allowing users to register in your app is one of those important things few know how to implement correctly. It requires knowledge about a whole range of complex things, that few software developers have time to study.

In the video below I am demonstrating how to use Magic's No-Code and Low-Code features to create it from scratch, in 15 minutes.

Posted on

Making Sense Of “Senseless” JavaScript Features

Why does JavaScript have so many eccentricities!? Like, why does 0.2 + 0.1 equals 0.30000000000000004? Or, why does "" == false evaluate to true?

There are a lot of mind-boggling decisions in JavaScript that seem pointless; some are misunderstood, while others are direct missteps in the design. Regardless, it’s worth knowing what these strange things are and why they are in the language. I’ll share what I believe are some of the quirkiest things about JavaScript and make sense of them.

0.1 + 0.2 And The Floating Point Format

Many of us have mocked JavaScript by writing 0.1 + 0.2 in the console and watching it resoundingly fail to get 0.3, but rather a funny-looking 0.30000000000000004 value.

What many developers might not know is that the weird result is not really JavaScript’s fault! JavaScript is merely adhering to the IEEE Standard for Floating-Point Arithmetic that nearly every other computer and programming language uses to represent numbers.

But what exactly is the Floating-Point Arithmetic?

Computers have to represent numbers in all sizes, from the distance between planets and even between atoms. On paper, it’s easy to write a massive number or a minuscule quantity without worrying about the size it will take. Computers don’t have that luxury since they have to save all kinds of numbers in binary and a small space in memory.

Take an 8-bit integer, for example. In binary, it can hold integers ranging from 0 to 255.

The keyword here is integers. It can’t represent any decimals between them. To fix this, we could add an imaginary decimal point somewhere along our 8-bit so the bits before the point are used to represent the integer part and the rest are used for the decimal part. Since the point is always in the same imaginary spot, it’s called a fixed point decimal. But it comes with a great cost since the range is reduced from 0 to 255 to exactly 0 to 15.9375.

Having greater precision means sacrificing range, and vice versa. We also have to take into consideration that computers need to please a large number of users with different requirements. An engineer building a bridge doesn’t worry too much if the measurements are off by just a little, say a hundredth of a centimeter. But, on the other hand, that same hundredth of a centimeter can end up costing much more for someone making a microchip. The precision that’s needed is different, and the consequences of a mistake can vary.

Another consideration is the size where numbers are stored in memory since storing long numbers in something like a megabyte isn’t feasible.

The floating-point format was born from this need to represent both large and small quantities with precision and efficiency. It does so in three parts:

  1. A single bit that represents whether or not the number is positive or negative (0 for positive, 1 for negative).
  2. A significand or mantissa that contains the number’s digits.
  3. An exponent specifies where the decimal (or binary) point is placed relative to the beginning of the mantissa, similar to how scientific notation works. Consequently, the point can move around to any position, hence the floating point.

An 8-bit floating-point format can represent numbers between 0.0078 to 480 (and its negatives), but notice that the floating-point representation can’t represent all of the numbers in that range. It’s impossible since 8 bits can represent only 256 distinct values. Inevitably, many numbers cannot be accurately represented. There are gaps along the range. Computers, of course, work with more bits to increase accuracy and range, commonly with 32-bits and 64-bits, but it’s impossible to represent all numbers accurately, a small price to pay if we consider the range we gain and the memory we save.

The exact dynamics are far more complex, but for now, we only have to understand that while this format allows us to express numbers in a large range, it loses precision (the gaps between representable values get bigger) when they become too big. For example, JavaScript numbers are presented in a double-precision floating-point format, i.e., each number is represented in 64 bits in memory, leaving 53 bits to represent the mantissa. That means JavaScript can only safely represent integers between –(253 — 1) and 253 — 1 without losing precision. Beyond that, the arithmetic stops making sense. That’s why we have the Number.MAX_SAFE_INTEGER static data property to represent the maximum safe integer in JavaScript, which is (253 — 1) or 9007199254740991.

But 0.3 is obviously below the MAX_SAFE_INTEGER threshold, so why can’t we get it when adding 0.1 and 0.2? The floating-point format struggles with some fractional numbers. It isn’t a problem with the floating-point format, but it certainly is across any number system.

To see this, let’s represent one-third (1/3) in base-10.

0.3

0.33

0.3333333 [...]

No matter how many digits we try to write, the result will never be exactly one-third. In the same way, we cannot accurately represent some fractional numbers in base-2 or binary. Take, for example, 0.2. We can write it with no problem in base-10, but if we try to write it in binary we get a recurring 1001 at the end that repeats infinitely.

0.001 1001 1001 1001 1001 1001 10 [...]

We obviously can’t have an infinitely large number, so at some point, the mantissa has to be truncated, making it impossible not to lose precision in the process. If we try to convert 0.2 from double-precision floating-point back to base-10, we will see the actual value saved in memory:

0.200000000000000011102230246251565404236316680908203125

It isn’t 0.2! We cannot represent an awful lot of fractional values — not only in JavaScript but in almost all computers. So why does running 0.2 + 0.2 correctly compute 0.4? In this case, the imprecision is so small that it gets rounded by Javascript (at the 16th decimal), but sometimes the imprecision is enough to escape the rounding mechanism, as is the case with 0.2 + 0.1. We can see what’s happening under the hood if we try to sum the actual values of 0.1 and 0.2.

This is the actual value saved when writing 0.1:

0.1000000000000000055511151231257827021181583404541015625

If we manually sum up the actual values of 0.1 and 0.2, we will see the culprit:

0.3000000000000000444089209850062616169452667236328125

That value is rounded to 0.30000000000000004. You can check the real values saved at float.exposed.

Floating-point has its known flaws, but its positives outweigh them, and it’s standard around the world. In that sense, it’s actually a relief when all modern systems will give us the same 0.30000000000000004 result across architectures. It might not be the result you expect, but it’s a result you can predict.

Type Coercion

JavaScript is a dynamically typed language, meaning we don’t have to declare a variable’s type, and it can be changed later in the code.

I find dynamically typed languages liberating since we can focus more on the substance of the code.

The issue comes from being weakly typed since there are many occasions where the language will try to do an implicit conversion between different types, e.g., from strings to numbers or falsy and truthy values. This is specifically true when using the equality ( ==) and plus sign (+) operators. The rules for type coercion are intricate, hard to remember, and even incorrect in certain situations. It’s better to avoid using == and always prefer the strict equality operator (===).

For example, JavaScript will coerce a string to a number when compared with another number:

console.log("2" == 2); // true

The inverse applies to the plus sign operator (+). It will try to coerce a number into a string when possible:

console.log(2 + "2"); // "22"

That’s why we should only use the plus sign operator (+) if we are sure that the values are numbers. When concatenating strings, it’s better to use the concat() method or template literals.

The reason such coercions are in the language is actually absurd. When JavaScript creator Brendan Eich was asked what he would have done differently in JavaScript’s design, his answer was to be more meticulous in the implementations early users of the language wanted:

“I would have avoided some of the compromises that I made when I first got early adopters, and they said, “Can you change this?”

— Brendan Eich

The most glaring example is the reason why we have two equality operators, == and ===. When an early JavaScript user prompted his need to compare a number to a string without having to change his code to make a conversion, Brendan added the loose equality operator to satisfy those needs.

There are a lot of other rules governing the loose equality operator (and other statements checking for a condition) that make JavaScript developers scratch their heads. They are complex, tedious, and senseless, so we should avoid the loose equality operator (==) at all costs and replace it with its strict homonym (===).

Why do we have two equality operators in the first place? A lot of factors, but we can point a finger at Guy L. Steele, co-creator of the Scheme programming language. He assured Eich that we could always add another equality operator since there were dialects with five distinct equality operators in the Lisp language! This mentality is dangerous, and nowadays, all features have to be rigorously analyzed because we can always add new features, but once they are in the language, they cannot be removed.

Automatic Semicolon Insertion

When writing code in JavaScript, a semicolon (;) is required at the end of some statements, including:

  • var, let, const;
  • Expression statements;
  • do...while;
  • continue, break, return, throw;
  • debugger;
  • Class field declarations (public or private);
  • import, export.

That said, we don’t necessarily have to insert a semicolon every time since JavaScript can automatically insert semicolons in a process unsurprisingly known as Automatic Semicolon Insertion (ASI). It was intended to make coding easier for beginners who didn’t know where a semicolon was needed, but it isn’t a reliable feature, and we should stick to explicitly typing where a semicolon goes. Linters and formatters add a semicolon where ASI would, but they aren’t completely reliable either.

ASI can make some code work, but most of the time it doesn’t. Take the following code:

const a = 1
(1).toString()

const b = 1
[1, 2, 3].forEach(console.log)

You can probably see where the semicolons go, and if we formatted it correctly, it would end up as:

const a = 1;

(1).toString();

const b = 1;

[(1, 2, 3)].forEach(console.log);

But if we feed the prior code directly to JavaScript, all kinds of exceptions would be thrown since it would be the same as writing this:

const a = 1(1).toString();

const b = (1)[(1, 2, 3)].forEach(console.log);

In conclusion, know your semicolons.

Why So Many Bottom Values?

The term “bottom” is often used to represent a value that does not exist or is undefined. But why do we have two kinds of bottom values in JavaScript?

Everything in JavaScript can be considered an object, except the two bottom values null and undefined (despite typeof null returning object). Attempting to get a property value from them raises an exception.

Note that, strictly speaking, all primitive values aren’t objects. But only null and undefined aren’t subjected to boxing.

We can even think of NaN as a third bottom value that represents the absence of a number. The abundance of bottom values should be regarded as a design error. There isn’t a straightforward reason that explains the existence of two bottom values, but we can see a difference in how JavaScript employs them.

undefined is the bottom value that JavaScript uses by default, so it’s considered good practice to use it exclusively in your code. When we define a variable without an initial value, attempting to retrieve it assigns the undefined value. The same thing happens when we try to access a non-existing property from an object. To match JavaScript’s behavior as closely as possible, use undefined to denote an existing property or variable that doesn’t have a value.

On the other hand, null is used to represent the absence of an object (hence, its typeof returns an object even though it isn’t). However, this is considered a design blunder because undefined could fulfill its purposes as effectively. It’s used by JavaScript to denote the end of a recursive data structure. More specifically, it’s used in the prototype chain to denote its end. Most of the time, you can use undefined over null, but there are some occasions where only null can be used, as is the case with Object.create in which we can only create an object without a prototype passing null; using undefined returns a TypeError.

null and undefined both suffer from the path problem. When trying to access a property from a bottom value — as if they were objects — exceptions are raised.

let user;

let userName = user.name; // Uncaught TypeError

let userNick = user.name.nick; // Uncaught TypeError

There is no way around this unless we check for each property value before trying to access the next one, either using the logical AND (&&) or optional chaining (?).

let user;

let userName = user?.name;

let userNick = user && user.name && user.name.nick;

console.log(userName); // undefined

console.log(userNick); // undefined

I said that NaN can be considered a bottom value, but it has its own confusing place in JavaScript since it represents numbers that aren’t actual numbers, usually due to a failed string-to-number conversion (which is another reason to avoid it). NaN has its own shenanigans because it isn’t equal to itself! To test if a value is NaN or not, use Number.isNaN().

We can check for all three bottom values with the following test:

function stringifyBottom(bottomValue) {
  if (bottomValue === undefined) {
    return "undefined";
  }

  if (bottomValue === null) {
    return "null";
  }

  if (Number.isNaN(bottomValue)) {
    return "NaN";
  }
}
Increment (++) And Decrement (--)

As developers, we tend to spend more time reading code rather than writing it. Whether we are reading documentation, reviewing someone else’s work, or checking our own, code readability will increase our productivity over brevity. In other words, readability saves time in the long run.

That’s why I prefer using + 1 or - 1 rather than the increment (++) and decrement (--) operators.

It’s illogical to have a different syntax exclusively for incrementing a value by one in addition to having a pre-increment form and a post-increment form, depending on where the operator is placed. It is very easy to get them reversed, and that can be difficult to debug. They shouldn’t have a place in your code or even in the language as a whole when we consider where the increment operators come from.

As we saw in a previous article, JavaScript syntax is heavily inspired by the C language, which uses pointer variables. Pointer variables were designed to store the memory addresses of other variables, enabling dynamic memory allocation and manipulation. The ++ and -- operators were originally crafted for the specific purpose of advancing or stepping back through memory locations.

Nowadays, pointer arithmetic has been proven harmful and can cause accidental access to memory locations beyond the intended boundaries of arrays or buffers, leading to memory errors, a notorious source of bugs and vulnerabilities. Regardless, the syntax made its way to JavaScript and remains there today.

While the use of ++ and -- remains a standard among developers, an argument for readability can be made. Opting for + 1 or - 1 over ++ and -- not only aligns with the principles of clarity and explicitness but also avoids having to deal with its pre-increment form and post-increment form.

Overall, it isn’t a life-or-death situation but a nice way to make your code more readable.

Conclusion

JavaScript’s seemingly senseless features often arise from historical decisions, compromises, and attempts to cater to all needs. Unfortunately, it’s impossible to make everyone happy, and JavaScript is no exception.

JavaScript doesn’t have the responsibility to accommodate all developers, but each developer has the responsibility to understand the language and embrace its strengths while being mindful of its quirks.

I hope you find it worth your while to keep learning more and more about JavaScript and its history to get a grasp of its misunderstood features and questionable decisions. Take its amazing prototypal nature, for example. It was obscured during development or blunders like the this keyword and its multipurpose behavior.

Either way, I encourage every developer to research and learn more about the language. And if you’re interested, I go a bit deeper into questionable areas of JavaScript’s design in another article published here on Smashing Magazine!

Posted on

The Art Of Looking Back: A Critical Reflection For Individual Contributors

Have you ever looked back at your younger self and wondered, “What was I even thinking?” If you have, then you know how important it is to acknowledge change, appreciate growth, and learn from your mistakes.

Søren Kierkegaard, the first existentialist philosopher, famously wrote:

“Life can only be understood by looking backward, but it must be lived forwards.”
— Søren Kierkegaard

By looking back at our past selves, we compare them not only to who we are today but to who we want to be tomorrow.

This process is called reflection.

Critical reflection is the craft of “bringing unconscious aspects of experience to conscious awareness, thereby making them available for conscious choice.” At its core, reflection focuses on challenging your takeaways from practical experiences, nudging you to explore better ways of achieving your goals.

Learning and growth are impossible without reflection. In the 1970s, David Kolb, an educational theorist, developed the “Cycle of Learning”, comprising four stages: Concrete Experience, Reflective Observation, Abstract Conceptualization, and Active Experimentation.

According to Kolb, each new experience yields learning when all of its aspects are analyzed, assessed, and challenged — in theory (through reflection and conceptualization) and in practice (through experimentation). In turn, new learning informs new experiences, therefore completing the circle: act, analyze, challenge, plan, repeat.

Reflection takes the central stage: it evaluates the outcomes of each concrete experience, informs future decisions, and leads to new discoveries. What’s more important, reflection takes every aspect of learning into consideration: from actions and feelings to thoughts and observations.

Design is, by nature, reflective. Ambiguity requires designers to be flexible and analyze the situation on the go. We need to adapt to the ever-changing environment, learn from every failure, and constantly doubt our expertise. Rephrasing Donald Schön, an American philosopher, instead of applying experience to a situation, designers should be open to the “situation’s back talk.”

On the other hand, designers often reflect almost unconsciously, and their reflections may lack structure and depth, especially at first. Reflection is the process of “thinking analytically” about all elements of your practice, but structureless reflection is not critical nor meaningful.

Luckily, a reflective framework exists to provide the necessary guidance.

Practicing Critical Reflection

In 1988, Professor Graham Gibbs published his book Learning by Doing, where he first introduced the Reflective Cycle — a framework represented by a closed loop of exercises, designed to help streamline the process of critical reflection.

In a nutshell, reflection comes down to describing the experience and your feelings towards it, analyzing your actions and thoughts, and devising an action plan. What sets it apart from a retrospective is continuity: the cycle is never complete, and every new iteration is built on the foundation of a previous one.

Imagine a situation: You are tasked with launching a survey and collecting at least 50 responses. However, a week later, you barely receive 15, despite having sent it to over a hundred people. You are angry and disappointed; your gut tells you the problem is in the research tool, and you are tempted to try again with another service.

Then, you take a deep breath and reflect on the experience.

Describe the situation

Begin by describing the situation in detail. Remember that a good description resembles a story, where every event is a consequence of past actions. Employ the “But & Therefore” rule of screenwriting and focus on drawing the connection between your actions and their outcomes.

First, provide a brief outline: What did you do, and how did it go?

Last week, I launched a research survey using Microsoft Forms, but despite my best efforts, it failed to collect a number of responses large enough to draw a meaningful conclusion. Upon analyzing the results, I noticed that a significant portion of the participants bounced from the question, which required them to choose a sector of a multi-layered pie chart.

Then, add some details: describe how you went about reaching your objective and what was your assumption at the time.

The technical limitations of Microsoft Forms made embedding a large image impossible, so I uploaded a low-resolution thumbnail and provided an external link (“Click to enlarge the image”). A large portion of participants, however, did not notice the link and couldn’t complete the task, stating that the image in the form was too small to comprehend. As a result, we have only collected 15 complete responses.

Recommendations

  • Avoid analyzing the experience at this stage. Focus on describing the situation in as many details as possible.
  • Disregard your experience and your gut urging you to solve a problem. Be patient, observant, and mindful.
  • Reflection doesn’t have to take place after the experience. In fact, you can reflect during the event or beforehand, trying to set the right expectations and plan your actions accordingly.

Describe Your Feelings

At this stage, focus on understanding your emotions before, during, and after the experience. Be mindful of the origin of your feelings and how they manifested and changed over time.

I was rather excited to see that Microsoft Forms offer a comprehensive set of survey tools. Moreover, I was captivated by the UI of the form, the option to choose a video background, and the feature that automatically calculated the time to complete the survey.

You will notice how describing your emotions helps you understand your motivations, beliefs, and convictions. In this particular example, by admitting to being enchanted by the platform’s interface, you essentially confirm that your decision was not a result of reasonable judgement or unbiased analysis.

I was somewhat disappointed to learn that I could not embed a large image, but I did not pay enough attention at the time.

This step is important: as your feelings change, so do your actions. A seemingly minor transition from “excitement” to “disappointment” is a signal that you have obviously overlooked. We will get back to it as we begin analyzing the situation.

Lastly, focus on your current state. How do you feel about your experience now when it’s over? Does any emotion stand out in particular?

I feel ashamed that I have overlooked such an obvious flaw and allowed it to impact the survey outcome.

Describing your emotions is, perhaps, the most challenging part of critical reflection. In traditional reflective practice, emotions are often excluded: we are commanded to focus on our actions, whether we are capable of acting rationally and disregard the feelings. However, in modern reflection, emotional reflection is highly encouraged.

Humans are obviously emotional beings. Our feelings determine our actions more than any facts ever could:

Our judgement is clouded by emotions, and understanding the connection between them and our actions is the key to managing our professional and personal growth.

Recommendations

  • Analyze your feelings constantly: before, during, and after the action. This will help you make better decisions, challenge your initial response, and be mindful of what drives you.
  • Don’t think you are capable of making rational decisions and don’t demand it of others, too. Emotions play an important role in decision–making, and you should strive to understand them, not obtain control over them.
  • Don’t neglect your and your team’s feelings. When reflecting on or discussing your actions, talk about how they made you feel and why.

Evaluate And Analyze

Evaluation and analysis is the most critical step of the reflective process. During this stage, you focus not only on the impact of your actions but on the root cause, challenging your beliefs, reservations, and decisions.

W3C’s guidelines for complex images require providing a long description as an alternative to displaying a complex image. Despite knowing that, I believed that providing a link to a larger image would be sufficient and that the participants would either be accessing my survey on the web or zooming in on their mobile devices.

Switching the focus from actions to the underlying motivation compliments the emotional reflection. It demonstrates the tangible impact of your feelings on your decisions: being positively overwhelmed has blinded you, and you didn’t spend enough time empathizing with your participant to predict their struggles.

Moreover, I chose an image that was quite complex and featured many layers of information. I thought providing various options would help my participants make a better-informed decision. Unfortunately, it may have contributed to causing choice overload and increasing the bounce rate.

Being critical of your beliefs is what sets reflection apart from the retelling. Things we believe in shape and define our actions — some of them stem from our experience, and others are imposed onto us by communities, groups, and leaders.

Irving Janis, an American research psychologist, in his 1972 study, introduced the term “groupthink”, an “unquestioned belief in the morality of the group and its choices.” The pressure to conform and accept the authority of the group, and the fear of rejection, make us fall victim to numerous biases and stereotypes.

Critical reflection frees us from believing the myths by doubting their validity and challenging their origins. For instance, your experience tells you that reducing the number of options reduces the choice overload as well. Critical reflection, however, nudges you to dig deeper and search for concrete evidence.

However, I am not convinced that the abundance of options led to overwhelming the participants. In fact, I managed to find some studies that point out how “more choices may instead facilitate choice and increase satisfaction.”

Recommendations

  • Learn to disregard your experience and not rely on authority when making important decisions. Plan and execute your own experiments, but be critical of the outcomes as well.
  • Research alternative theories and methods that, however unfamiliar, may provide you with a better way of achieving your goals. Don’t hesitate to get into uncharted waters.

Draw A Conclusion And Set A Goal

Summarize your reflection and highlight what you can improve. Do your best to identify various opportunities.

As a result, 85% of the participants dropped out, which severely damaged the credibility of my research. Reflecting on my emotions and actions, I conclude that providing the information in a clear and accessible format could have helped increase the response rate.
Alternatively, I could have used a different survey tool that would allow me to embed large images: however, that might require additional budget and doesn’t necessarily guarantee results.

Lastly, use your reflection to frame a SMART (Specific, Measurable, Achievable, Relevant, and Time-Bound) goal.

Only focus on goals that align with your professional and personal aspirations. Lock every goal in time and define clear and unambiguous success criteria. This will help you hold yourself accountable in the future.

As my next step, I will research alternative ways of presenting complex information that is accessible and tool-agnostic, as this will provide more flexibility, a better user experience to survey participants and ensure better survey outcomes for my future research projects. I will launch a new survey in 14 days and reflect accordingly.

At this point, you have reached the conclusion of this reflective cycle. You no longer blame the tool, nor do you feel disappointed or irate. In fact, you now have a concrete plan that will lead you to pick up a new, relevant, and valuable skill. More than that, the next time the thrill takes you, you will stop to think about whether you are making a rational decision.

Recommendations

  • SMART is a good framework, but not every goal has to fit it perfectly. Some goals may have questionable relevancy, and others may have a flexible timeline. Make sure you are confident that your goals are attainable, and constantly reflect on your progress.
  • Challenge your goals and filter out those that don’t make practical sense. Are your goals overly ambiguous? How will you know when you have achieved your goal?
Daily Reflection

Reflection guides you by helping you set clear, relevant goals and assess progress. As you learn and explore, make decisions, and overcome challenges, reflection becomes an integral part of your practice, channels your growth, and informs your plans.

Reflection spans multiple cognitive areas (“reflective domains”), from discipline and motivation to emotional management. You can analyze how you learn new things and communicate with your peers, how you control your emotions, and stay motivated. Reflecting on different aspects of your practice will help you achieve well–balanced growth.

As you collect your daily reflections, note down what they revolve around, for example, skills and knowledge, discipline, emotions, communication, meaningful growth, and learning. In time, you may notice how some domains will accumulate more entries than others, and this will signal you which areas to focus more on when moving forward.

Finally, one thing that can make a continuous, goal-driven reflective process even more effective is sharing.

Keeping a public reflective journal is a great practice. It holds you accountable, requires discipline to publish entries regularly, and demands quality reflection and impact analysis. It improves your writing and storytelling, helps you create more engaging content, and work with the audience.

Most importantly, a public reflective journal connects you with like-minded people. Sharing your growth and reflecting on your challenges is a great way to make new friends, inspire others, and find support.

Conclusion

In Plato’s “Apology,” Socrates says, “I neither know nor think I know.” In a way, that passage embodies the spirit of a reflective mindset: admitting to knowing nothing and accepting that no belief can be objectively accurate is the first step to becoming a better practitioner.

Reflection is an argument between your former and future selves: a messy continuous exercise that is not designed to provide closure, but to ask more questions and leave many open for further discussions. It is a combination of occasional revelations, uncomfortable questions, and tough challenges.

Reflection is not stepping out of your comfort zone. It is demolishing it, tearing it apart, and rebuilding it with new, better materials.

Don’t stop reflecting.

Further Reading on Smashing Magazine

Posted on

ShipHero Review

ShipHero is a cloud-based solution that offers warehouse, inventory management, and fulfillment services to ecommerce brands. ShipHero started in 2013 with a cloud-based warehouse management system (WMS) application. It expanded to add order fulfillment services in 2019, just in time for the increase in online shopping due to the global pandemic.

ShipHero offers one-click integration with all major ecommerce shopping platforms and has seven physical warehouse locations throughout the United States. It boasts a flat rate, no zone approach to order fulfillment, making it appealing to ecommerce brands looking for a simplified approach to monthly shipping costs.

ShipHero logo

ShipHero Compared

ShipHero did not make our top list of ecommerce fulfillment services. The best ecommerce fulfillment service is ShipBob because it is easy to use, offers two-day shipping in the U.S., and also offers retailer dropshipping and B2B fulfillment. Get started with ShipBob’s self-service Growth Plan for startups today.

Whatever your needs, one of these ecommerce fulfillment services will help you streamline delivery and ensure customer satisfaction.

About ShipHero

ShipHero is somewhat unique among ecommerce fulfillment services, in that it started life as a warehouse management app and then added fulfillment later on. Now that it offers both services, ShipHero is a one-stop solution for ecommerce brands’ storage, management, and delivery needs.

ShipHero’s suite of services and solutions includes fulfillment services, a warehouse management system, integrations with top platforms for ecommerce like Shopify and WooCommerce, an API for developers, and a nationwide network of seven warehouses across the U.S. They also offer a flat-rate/no zone pricing approach for fulfillment, and no cost for setup, software, onboarding, and product receipt.

ShipHero Health and Stability

ShipHero was founded in 2013 as an online platform for warehouse management. In 2019, they expanded to also offer order fulfillment services. It is a privately held startup that competes with a significant number of other startups offering similar services – many with similar names.

ShipHero has received two rounds of private equity funding. In November 2021 it received funding of $10.4 million from investor Joe De Pinho. Seven months later, Riverwood Capital invested $50 million. ShipHero planned to seek a third round of funding in June 2022 but put plans on hold due to the weakening economy and the post-pandemic decline in online shopping.

ShipHero services more than 5,000 ecommerce brands and 3PLs around the world. As would be expected, ShipHero flourished during the pandemic years when online shopping was at its peak. However, it struggled to meet demand during the peak fall and winter shipping season of 2022, resulting in several negative reviews by customers starting in December 2022. To its credit, ShipHero acknowledged those issues and committed to improving processes in Q1 of 2023.

Like all the startup fulfillment services in this space, ShipHero is vulnerable to external economic forces and fluctuating customer demand. There are also many similar competitors in this space. Time will tell whether ShipHero rises above its competition or is acquired by another brand.

ShipHero Pricing

For its ecommerce fulfillment services, ShipHero does not provide any price information on its website. Instead, you must request a quote and meet with its fulfillment team. Then you’ll receive a customized quote based on your unique requirements.

ShipHero is more transparent when it comes to its warehouse management system. It offers three tiers of pricing, including Standard WMS for Brands, WMS for 3PLs, and Enterprise WMS for Brands.

ShipHero Pricing Structure

ShipHero’s ecommerce fulfillment services are not transparent. The only information provided on the ShipHero website is that fulfillment pricing is flat rate and doesn’t rely on zones to calculate costs for domestic shipping in the U.S. The flat rate includes picking the order, packing, the box, and postage. 

ShipHero’s warehouse management system is more clear. Pricing starts at $1,995 for the Standard plan and $2,145 for the 3PLs plan. Enterprise customers must get a quote. All three tiers include five users, with additional users added at $150 each per month. All plans include unlimited SKUs, multiple warehouses, API access, and unlimited orders.

ShipHero Pricing Comparison

ShipHero’s pricing for ecommerce fulfillment services is not disclosed. Contrast this with some of its closest competitors that put baseline prices on their websites: ShipBob starts at between $5.66 to $6.03, ShipMonk begins at $3 per single item order, and Easyship offers a starter plan that includes up to 50 packages per month for free, although you must pay for postage through your own shipping account.

Despite ShipHero’s refusal to disclose fulfillment pricing, it does highlight its flat rate/no zone approach as a unique selling point. Both ShipBob and Red Stag Fulfillment charge by package dimensional weight and shipping zone. 

ShipHero takes a different approach with its Warehouse Management Services fees, which it does disclose. Monthly plans start at $1,495 per month (Standard) and $2,145 (3PL). However, its direct competitors in this space, including Red Stag Fulfillment and ShipBob, go in the other direction and keep their warehouse management service pricing hidden. You’ll need to get a quote in order to compare those services to ShipHero.

ShipHero Trials and Guarantees

ShipHero does not offer any free trials or introductory pricing on its website. They also require full payment upfront to start using their services. 

However, they do offer a 30-day money-back guarantee. While this is not promoted on their website, they mention it in responses to customer reviews on sites like Capterra, TrustPilot, and G2.

ShipHero Ecommerce Fulfillment Services Review

ShipHero is an app-based ecommerce fulfillment platform that also offers a warehouse management system. Its streamlined approach to pricing – offering a flat rate and no zone differentials – is unique among its chief competitors.

While ShipHero didn’t make our top list of ecommerce fulfillment services, it may be a good option for online shops that prioritize consistent monthly fulfillment costs.

What Makes ShipHero Ecommerce Fulfillment Services Great

Two lists titled "Life Before ShipHero" and "Life After ShipHero" with a list of ShipHero features
ShipHero streamlines your ecommerce sales with warehouse management and outsourced order fulfillment.
  • All-in-one solution: One of the selling points of ShipHero is the ability to coordinate fulfillment and warehouse management in one tool. For ecommerce sellers that need both, this is a streamlined approach that saves time and reduces the need to rely on multiple apps to solve different needs.
  • Great customer service: ShipHero customers consistently praise the helpful and fast customer support they receive. From providing timely and thorough responses to going above and beyond to proactively resolve issues before they actually become issues, the ShipHero customer service team consistently receives kudos and shout-outs.
  • Easy to use: Another win for ShipHero is its intuitive user interface and app navigation. A consistent theme heard from users is how easy it is to get new employees up and running on ShipHero, often in less than 15 minutes. Many users have cited this as a determining factor in allowing them to bring fulfillment back in-house instead of relying on 3PL providers.
  • Streamlined onboarding: ShipHero makes onboarding easy with one-on-one setup and training. This onboarding assistance is included at no additional charge in their Standard warehouse management system package.  
  • In-depth reporting: Users consistently rate ShipHero’s reporting as a big plus of the product. In-depth reports are easy to pull and very detailed. 

Where ShipHero Ecommerce Fulfillment Services Fall Short

ShipHero fulfillment services landing page
ShipHero offers flat rate pricing and fast shipping from multiple warehouse locations, but struggles with consistent performance.
  • Inconsistent performance record: Numerous customer reviews note extreme delays with order fulfillment during the peak fall-winter season of 2022. ShipHero acknowledged struggling in this regard and promised to make improvements in Q1 of 2023. However, this inconsistent performance seems to be cyclical, with periods of optimal service bracketed with months of struggle, as noted in customer reviews over the years. ShipHero must focus on mastering consistent exemplary customer service to remain competitive.
  • No free trial or special offers to get started: Unlike its competitors ShipMonk and ShipBob, who both let new customers self-onboard for free, ShipHero doesn’t offer any options like that to new customers. Payment is required up front to begin service. ShipHero does, however, claim to offer a 30-day money-back guarantee, although this isn’t advertised on their website. To become more competitive, ShipHero should consider more transparency and a more customer-centric approach to starting with their services.
  • High price/warehouse management packages could be more robust: Although their pricing for order fulfillment is not readily available on their website, a recurring theme in customer reviews is that fees are a bit high. Another complaint was that not enough user seats are included in the baseline pricing of ShipHero’s warehouse management system packages.
  • Hard to reach: While ShipHero might garner many positive reviews for customer service, getting that service started can be a point of contention. Current customer support involves submitting a ticket and waiting for a response. There is no customer support telephone number available. To remain competitive, ShipHero should consider multiple customer communication channels.

Ecommerce Fulfillment Services Compared

While ShipHero offers several compelling features that make it a good solution for some ecommerce brands, other fulfillment services are a better alternative. 

If you’re an ecommerce brand that wants to streamline order fulfillment and better manage your warehouse, be sure to read our Best Ecommerce Fulfillment Services review, then take a deeper look at ShipBob, our top recommendation.

Final Verdict

ShipHero has been involved in the ecommerce brand space for nearly ten years with its warehouse management system. It ramped up its order fulfillment services in 2019 and offers an enticing flat rate/no zone approach to shipping products. 

However, we recommend considering other options like ShipBob for most ecommerce brands. You can find out more about who we recommend and why in our Best Ecommerce Fulfillment Services review.

Posted on

Five Steps To Design Your Product With Powerful Storytelling

I can’t imagine the digital world without the magic of storytelling. While I consider storytelling as an art, it is also a discipline that has its roots in Ancient Greece and Aristotle’s writing: Poetics:

“A whole [story] is what has a beginning and middle and end.”

In this essay, the Greek philosopher identified for the first time the three main components of a story: beginning, middle, and end, and how they each related to one another.

“A beginning is that which is not itself necessarily after anything else, and which has naturally something else after it. An end is that which is naturally after something itself, either as its necessary or usual consequent and with nothing else after it. And a middle, that which is by nature after one thing and also has another after it.”

Aristotle’s three-act structure has remained unchanged since 300 BC. Although many writers, screenwriters, and film directors have conducted a variety of complex experiments, the most successful stories never stray from this basic root.

Today, designers use the same structure to map user experiences and design user-centered products. A remarkable and memorable example of the power of storytelling is the change in Apple’s direction of communication on Steve Jobs’ return. He had spent some time running Pixar, and his experience with the company’s storytellers was essential to what happened next at Apple: the belief that by focusing on customers’ needs and tapping into their stories, they would sell more computers. (They did, of course!)

However, designers cannot become good storytellers by using Aristotle’s three-act structure alone. We must also identify specific storytelling elements to help develop our narrative.

In the following five steps, we will tap into each of the different elements of storytelling, with a running example of the approach I used to design the experience and interface behind the video course landing page.

Meet Smart Interface Design Patterns, our new video course on interface design & UX. Step 1: Understand Your Protagonist And The Purpose Of The Product

As designers of experiences, we need to build beautiful interfaces that create meaningful interactions with our audience. So before imagining the layout of the landing page, I needed to find an answer to a critical question: who is our protagonist?

The protagonist is the hero of our story. The story, therefore, is never about the product we sell. It is always about the protagonist, who reflects the audience’s own interaction with that product.

So to answer the first question, we need to know our protagonist’s needs, goals, fears, and frustrations. This is the rule number one for every UX designer, just as it is for any storyteller.

When you need insights about your protagonist, you can use a set of questions to conjure a most likely persona. If the product already exists in the market, you can use other research tools, like usability testing or heat maps. In my case, Vitaly Friedman, the creator of the video course, had already identified his target ahead of time, during the workshops and conferences he had completed in the past year.

Watching the video chapters of the course, I understood that our story’s protagonists would be UX and UI designers with a beginner to advanced level of knowledge about design and interface design patterns.

The frustration of these protagonists is usually the lack of time to research and learn. Specifically, those who are trying to fully embrace the world of UX design wish to learn design patterns quickly, so they can figure out the reasons why one might offer a better experience than another. On the other hand, a more experienced target group doesn’t have time to stay updated with the latest UX best practices between projects.

Our protagonists’ needs and story, therefore, define our story’s purpose: Why does this story matter to them?

Defining the why of the story is always a challenging step of storytelling. It only becomes easy once you know your protagonist well. The audience will only stick around if the story resonates with them. Additionally, a story without a clear purpose is hazy and irrelevant, so the story’s intention must be defined upfront.

Re-articulating Simon Sinek’s Golden Circle, a stickable story needs to know the purpose of its existence, i.e. the audience problem it is trying to solve (why), what sets it apart from others (how), and at the end, the product and service it is selling to solve the problem (what).

This is what the Golden Circle looks like when applied to the experience design for the landing page:

  • The why of our story tapped into our protagonists’ frustrations about the lack of time. So our story is first about communicating that learning is an investment. Secondly, through Vitaly’s own experience and research, they will save time and effort.
  • The how reflects on their learning goals and staying up to date: if they are hungry for knowledge, they will be satisfied.
  • The what is a reflection on the WHY and HOW. We want people to subscribe to the video course only after evaluating its benefits and tasting the material (adding some valuable features during navigation with free samples, previews, extra gifts, and persuasive elements, like testimonials).

The protagonist and the purpose are the elements that propel us to the next step of our narrative: the plot.

Step 2: Define The Structure Of Your Narrative

Aristotle teaches us that stories must be a chain of cause-and-effect moments. Each scene must lead to what happens next and not work as a standalone episode, no matter how attractive and well-executed it is. Remember, the plot must also have a beginning, middle, and end.

In his book, Building a Story Brand, Donald Miller examines the cause-and-effect structure as follows: a protagonist aims for something, but in her quest, she encounters a problem. During her journey, a guide steps into her life and shows her a plan that invites her to action. By acting, the protagonist will avoid failure and end her story in a success. He calls this structure the StoryBrand Structure.

For every project, whether a digital product or brand design, I combine Miller’s StoryBrand format with Aristotle’s three-act structure to convey a clear sense of continuity throughout the narrative.

Then I work on each act individually, analyzing every element of the narrative.

The Beginning

The beginning, also known as the first act, is the setup.

In UX design, this is the moment where we meet our protagonist (the hero) with her problems and goals, as analyzed in the previous step.

At the end of Act I, our protagonist meets a guide. The guide is not another hero. They simply act as a helping hand, showing the protagonist how to move forward in her transformational journey. You could use the plot of your favorite movie as an example of how this occurs.

Here’s an example from my own favorite childhood movie, The Neverending Story. The child-protagonist, Bastian, is neglected by his father and bullied at school (problem). Trying to escape the bullies, Bastian enters a bookstore, annoying the bookseller (the guide) who is reading an interesting book that is not for children. Secretly, Bastian takes the book, titled The Neverending Story, and reads it in the school’s attic.

The book describes the fantasy world of Fantasia, which is slowly being devoured by a malevolent force called “The Nothing”. The Childlike Empress, who rules Fantasia, has fallen ill, and the young warrior Atreyu is tasked to discover a cure, believing that once the Empress is well, The Nothing will no longer be a threat.

Bastian soon understands that the book he is reading will save Fantasia from disappearing (the plan), and he needs to give a new name to the princess (Action) to help Atreyu win his battle against The Nothing (avoid failure). Then, he will save the Childlike Empress and her Empire (success).

So, when identifying the guide of your story, whether a person, a service, a product, or a brand, ensure it is someone the audience will trust and follow because they feel understood and in safe hands. The guide’s inner qualities are empathy and authority, which should be reflected in every communication material they share with their audience.

In the landing page example, our story’s guide is Vitaly Friedman. Investigating his profile, I established a past of remarkable work sharing resources and best practices in Smashing Magazine and many conferences, workshops, and online. On social media, Vitaly has built a strong reputation in his community as a UX expert and extremely knowledgeable in this field. He, therefore, possesses all the traits of a guide.

The Middle

The middle, also known as the second act, is the confrontation. In this specific part of the story, we assist the transformation of the protagonist and her emotional state (this transformation is also known as the character arc).

At the beginning of the second act, the guide gives the protagonist a plan. The question the protagonist expects the guide to answer is, “What do you want me to do now?”

In the middle of The Neverending Story, we discover that Bastian needs to follow a precise plan: he needs to give a new name to the Childlike Empress to prevent the dissolving of Fantasia.

So the plan needs to be clear, highlighting every step and removing any sense of risk or doubt that our protagonist may have in considering it. By giving your users a plan, you set a clear path to help them move forward in their journey.

In the case of the landing page, I asked Vitaly to list the content of his offer and explain the simple steps that must be taken to subscribe to the available plans. I then underlined the unique values and the plan for each subscription and designed a simple overview.

At the end of the second act, the guide must clearly communicate what action the protagonist needs to perform with the plan.

In The Neverending Story, the protagonist Bastian is in complete disbelief that he is part of the solution, and moved by the Empress begging, he calls out the new name, running to the attic window to call out “Moon Child”.

In the same way, when we sell a service or a product, we need to invite the users to take a journey with us, just as we have via the landing page. If we plainly tell them, they will know what to do with our well-laid plan.

Vitaly invites the audience to act in two ways. One is a direct call to action through a "Buy"-button that is positioned on different parts of the landing page. The other is a transitional call to action through free video episodes, email newsletter and content samples.

Transitional actions also come in other forms:

  • testimonials from other experts in the field, and
  • unlimited access to the UX checklists, an elegant deck of 165 cards to learn and recall basic design patterns for successful digital experiences.

The End

The ending is the story’s third and final act.

It is here that we will decide how our protagonist will succeed in her goal or avoid failing. In doing so, we need to achieve the peak of our story or climax by specifying what’s at stake if the user (or the protagonist) doesn’t engage with us.

It is essential to find the right balance in how we introduce negative consequences, so we can avoid generating fear that will parallyze and freeze the protagonist from moving forwards in her journey.

In The Neverending Story, when the Childlike Empress begs Bastian, she tells him that Fantasia will disappear without his help, and so will his favorite hero, Atreyu, and his dragon Falkor. She taps into Bastian’s wishes of belonging to something bigger than himself, thereby proving that he is worthy. This a desire we sense the protagonist seems to aspire to since the beginning of the movie when he seeks his father’s attention or tries to escape his bullies.

For the video course, we remind the user that she can only become an expert after a while and that it would probably take many years of research and reading and studying to become good at UX. So why not build the knowledge on top of well-explained, curated foundation and jump into a course with Vitaly, who has “cooked” the best recipes and bulletproof design patterns over 15 years?

We should remember that our story’s goal is to motivate our users to become better versions of themselves, and that they need only start this journey with us to achieve such an incredible transformation!

For this particular reason, the third act is also called the resolution. When designing a user journey, we also define a list of resolutions to the protagonist’s problem. In designing the user experience for the landing page, the list was created from a mix of status and inspirational resolutions:

  • Self-improvement: Become an influential and more knowledgeable UX designer, and receive a UX certificate.
  • Networking opportunities: Join an advanced UX workshop where you will meet Vitaly, get feedback from him personally and work with other designers around the world.
  • Improve the web: Work confidently towards designing better digital experiences on the web.

These resolutions were presented in different parts of the landing page to remind the user why she is on this journey with us, and where we wish to take her.

Step 3: Connect The Plot With A Wireframe

Now that all of the story elements are in place, it is essential to understand how they will fit together and connect on the landing page. I usually think about each page of the website as a single shot with its beginning, middle, and end scenes. Many of these shots make a scene, and a series of scenes make an entire website or application.

Following the plot I created in the previous step, I started out by organizing the content and adding critical plot points.

Plot points in dramaturgy are incidents that directly impact what happens next in a story. When used well, they help the protagonist move forward in her journey. In UX, the plot points work precisely in the same way. They are actions (for example, “buy now” buttons), barriers (logins or forms to fill), delights (unexpected interactions or free samples), system events (confirmation messages and emails), and triggers (notifications) that the user needs to perform to move forward in their journey.

Using a simple piece of dotted paper, I usually start sketching how my story’s content will ideally be displayed between the different parts of the page. You may wonder about the mobile-first approach at this point. When designing an experience as we are doing right now, what matters is ensuring it is consistent with our story and that it can be replicated on every media, no matter the pixel size or the support used.

So if you wish to start with mobile or a large screen, our aim is to define the user journey in a way that could be transformed into an interface for the landing page (as in our case), in a leaflet, or in a marketing campaign.

Opening Scene

The opening scene sets up the story’s premise and is the first element of the page that the user will see, regardless of which website or application she lands on. The upper area of the page presents the product or service to the audience.

We wanted to induce curiosity in our protagonist in this specific part of the page. For this reason, the content needs to be engaging and compelling, prompting the user to scroll down for more. I would add a trigger that actively invites the user to “scroll down” to the next part of the shot, the middle scene.

Middle Scene

The middle scene of our shot is the place where most of our narrative will happen. We will introduce our protagonist to the guide, the plan, and the action we wish them to perform. There will be a section that explains the video course and the content in full detail, with content samples and other elements that will help users better understand and explore the video course.

To build authority and trust around our experience, we do not simply introduce Vitaly but also a series of testimonials from other experts. Our protagonist is no longer curious but armed with relevant information! She needs a clear reason to engage with our product. For this reason, any action or plot point added should satisfy this specific emotional aim.

Closing Scene

The closing scene is the resolution of our plot.

As previously explained, we offer two plans that evoke two specific outcomes; we are not simply asking which plans our protagonist wants, but what kind of transformation she is aiming for. Here the user is mindful, so we need to ensure nothing distracts her from the decision-making.

So in this specific scene, the “Buy”-button is the one and only action we wish our user to focus on.

The footer and the top navigation are complementary elements of our narrative. The navigation facilitates the journey, while the footer provides more engagement in case our hero needs additional time to decide or wishes to join the larger community that Vitaly is serving.

Step 4: Add Emotional Connection To Create A Memorable Story

The first three steps focused on the user journey and page content. In this step, we think about making the story memorable for our users. Otherwise, our landing page will look like any other random page!

Emotional connection is an essential part of the storytelling process and can be conveyed through visual elements like colors, sounds, illustrations, animations, and images. These play a huge role in motivating and giving intention to the actions taken by the user.

To find the central theme of our landing page, I focused on critical elements and designed a map with keywords to help me create a forced connection, another wonderful aspect of storytelling that is based on combining disparate functions, materials, or processes.

This process is used to generate disruptive ideas and original concepts:

  • Our users’ needs (hungry users): learning fast, getting the best lessons in UX, and hungry for knowledge.
  • The set (kitchen): a friendly and informal kitchen.
  • Vitaly’s role (chef): experienced teacher, UX expert and guide.
  • The tools (recipes): real-time examples, blackboard, notes, video courses, and slides.

These elements all remind me of a well-designed food experience conveniently delivered right to your door: our “knowledge-hungry” users can follow Vitaly’s recipes (the videos) at their own pace. Each recipe has been prepared and cooked by Vitaly, packed with the best nutritional elements (tips, tools, examples. slides, and so on) that create strong and compelling designs.

The color palette is a mix of inspiration from the blackboard that opens each episode of the course, the primary red of the Smashing Magazine theme, and the wonderful video course illustrations by Guillaume Kurkdijan.

I then used the previous wireframe and enriched it with sketches that could complete and clarify the scene. These sketches served as a blueprint for the final illustrations.

Opening Scene

A rich starter to introduce some of the design patterns taught in the course is accordion UX (the spring with fish), reviews and ratings (stars), cookies (the biscuit), hamburger menu (the spaghetti), adding personality to the web (salt and pepper).

The illustration matches the user’s emotional state, curiosity, by surprising her with an unexpected food theme.

Middle Scene

We decided to introduce Vitaly with images showing him involved in teaching, while the course chapters are like cookbooks on the shelf, shown through a carousel.

My favorite illustration is the Buddha Bowl, which is used to introduce all the content provided during the course. This illustration satisfies our protagonist’s need for more information. It is interactive so that from the ravioli to the small bottle of oil, the audience can explore the nutritional elements that make this course so unique and flavourful!

End Scene

Three small illustrations introduce the available plans that tap into the resolutions we mention in step 2. The illustrations for each plan are relevant to the plans but presented small to avoid interfering with the focused state of our protagonist.

An empty bowl suggests that our users have now eaten a part of the content, but if they are still hungry, there are more ways to engage with Vitaly.

Additional small illustrations, all food related, introduce the different sections of the landing page and their content. Talented animator, Cassie Evans, brought these illustrations to life with subtle animations so that the entire landing page is playful and appealing.

Step 5: Test Our Narrative Before Engaging With Our Customers

Before presenting an idea to customers, I usually follow a detailed check to ensure that the final design still represents the user’s story, as outlined during the previous steps.

Some of the questions I ask myself are the following:

What Primary Action Do I Want The User To Take On This Page?

The answer references the story element action. I usually check if there are enough plot points, like buttons and triggers, on the page to engage the user at different stages of her journey.

What Secondary Action Do I Want The User To Take?

This answer relates to the transitional actions, which means anything that invites the user to engage with us in other ways before they click the “Buy”-button.

How Am I Supporting The Need To Scroll For More Details?

In this case, my attention switches to the plot and the cause-effect element that define the narrative. Looking at the structure laid out in step 2, I check if the scenes included in the landing page still follow the logic of the user’s journey and if there are enough plot points to carry the narrative.

Does Any Content Distract The User, Or Prevent Her From Completing Her Task?

This question focuses on the clarity of the message and our resolutions. In general, each page should focus on a specific outcome. Anything that blurs our intentions should therefore be removed.

Different parts of the landing page refer to our three resolutions, with the entire page built around them.

Can We Anticipate The Final Action?

The answer to this question usually relies on the user’s ability to jump into the climax of the story quickly, to the action (in our case: available plans with “Buy”-buttons). Think about fast-forwarding your favorite movie to get to the most thrilling scene or leafing to the last page of a book to discover who the killer is!

In the case of a landing page, the “Buy”-button is at the beginning of the navigation and follows the user as she scrolls… so she can jump to the story’s third act at any time she likes.

Conclusion

As we have discovered, storytelling is more than just another business buzzword. Storytelling is an exciting and strategic approach with rules and clear principles that, when used well, can help brands stand out from the crowd with a clear message and a user-centric approach. It’s an essential skill that designers should embrace, no matter their specialization or profile.

As such, the different steps I have illustrated will help you to:

  • Identify your protagonist and build a powerful, purposeful story that speaks to their frustrations and goals.
  • Create a user journey that directly relates to the protagonist’s story.
  • Structure that journey as a wireframe to identify your chosen story content based on the narrative structure.
  • Create an emotional bond with the user by adding meaningful illustrations.
  • Check the story’s narrative with questions that evaluate your use of the wider storytelling process.

Precisely as it occurs in the world’s most acclaimed movies, building a solid narrative structure guides you in creating scenes and chapters that are consistent with the user’s own story.

In this way, you can use the plot of a solid, recognizable, and popular narrative as a base from which to create additional scenes and chapters, and even successive sequels — as a great many movie franchises have achieved with thrilling effects.

In fact, the same plot illustrated in this post for the landing page helped me to create a warm and instantly recognizable design for Vitaly’s upcoming secretive new project. Still, as the narrative voice of The Neverending Story reminds us, “that is another story, and shall be told another time!”

Where everything is coming together: Smart Interface Design Patterns.

You can find the final result now live on Smart Interface Design Patterns, created with incredible contributions by so many talented and hard-working people:

Thank you for your incredible work, everyone! 👏🏼👏🏽👏🏾

Posted on

400: Hiatus

Marie and I jump on the show to tell y’all we’re taking a little break! It feels like years since we’ve been eluding to the fact that we’re working on a new major upgrade to CodePen. Rather than keep dancing around it, we’re going to minimize or remove working on anything that isn’t working on that. We can’t wait to come back for episode 401 and tell you all about it.

Time Jumps

  • 00:14 Welcome
  • 00:56 What’s happening with CodePen Radio?
  • 02:13 Early days of CodePen Radio
  • 04:43 Sponsorship simplified
  • 07:20 Sponsor: Split.io
  • 08:06 Documenting the history of CodePen through the podcast
  • 10:35 Funny stories from past episodes
  • 13:34 The next phase of CodePen
  • 15:19 Thanks for listening

Sponsor: Split

This podcast is powered by Split. The Feature Management & Experimentation Platform that reimagines software delivery. By attaching insightful data to feature flags, Split frees you to quickly deploy, measure, and learn the impact of every feature you release. So you can safely deliver features up to 50 times faster and exhale. What a Release.

Start raising feature flags (and lowering stress). Visit Split.io/CodePen for a free trial.

The post 400: Hiatus appeared first on CodePen Blog.

Posted on

399: Data Munging

There was a small problem in our database. Some JSON data we kept in a column would sometimes have a string instead of an integer. Like {"tabSize": "5"} instead of {"tabSize": 5} of the like. Investigation on how that happened was just silly stuff like not calling parseInt on a value as it came off a <select> element in the DOM. This problem never surfaced because our Rails app just papered over it. But we’re moving our code to Go in when you parse JSON in Go, the struct type that you parse it out into needs to match those types perfectly, or else it panics. We had found that our Go code was working around this in all sorts of ways that felt sloppy and inconsistent.

One way to fix this? Fix any bad data going into the DB, then write a script to fix all the data in the DB. This is exactly the approach I took at first, and it would have absolutely fixed this problem.

But Alex took a step back and looked at the problem a bit wider, and we ended up building some tools that helped us solve this problem, and solve future problems related to this. For one, we built a more permission JSON parser that would not panic on something as easy to fix as a string-as-int problem. This worked by way of some Go reflection that could tell what types the data was supposed to be and coerce them if possible. But what should the value fall back to if it’s not savable? That was another tool we built to set the default values of Go structs to be potentially other values than what the defaults for their types are. And since this is all in the realm of data validation, we built another tool to validate the data in Go structs against constraints, so we can always keep the data they contain good.

Once all these tools were in place, the new script to fix the data was much easier to write. Just call the safe JSON function to fix the data and put it back. And the result is a cleaned up code base and tools we can use for data safety for the long term.

Time Jumps

  • 00:29 How can we fix the problem forever?
  • 03:53 Chris becomes a Go-pher
  • 15:04 Building rules that will work for anything, not just this situation
  • 18:54 Setting up proper testing is huge
  • 20:19 Sponsor: Intelligent Demand
  • 21:06 Testing for pointers
  • 25:18 Using GORM
  • 27:08 Supabase postgresDB

Sponsor: Split

This podcast is powered by Split. The Feature Management & Experimentation Platform that reimagines software delivery. By attaching insightful data to feature flags, Split frees you to quickly deploy, measure, and learn the impact of every feature you release. So you can safely deliver features up to 50 times faster and exhale. What a Release.

Start raising feature flags (and lowering stress). Visit Split.io/CodePen for a free trial.

The post 399: Data Munging appeared first on CodePen Blog.

Posted on

TextMarks Review

Although email marketing is thriving, SMS marketing has swiftly become just about as popular. TextMarks provides a simple way to send out mass text messages to generate leads, share information, or offer promotions to customers.

TextMarks assists various industries with its easy-to-use mass text marketing tool, including nonprofits, education, and healthcare. Depending on your plan, you can send unlimited messages with as many custom keywords as needed per month.

TextMarks logo

TextMarks Compared

TextMarks did not make our top list of the best business text messaging services. SimpleTexting is our top suggestion for most businesses because of its versatility, allowing for everything from mass marketing to two-way texting. Try SimpleTexting free for 14 days.

  • SimpleTexting – Best texting service for marketing and sales
  • Textedly – Best for bulk texting
  • OpenPhone – Best for unlimited calling and texting
  • Podium – Best for text-to-pay
  • Sendinblue – Best for texting combined with email services

Learn more about our picks for the best business text messaging services. 

About TextMarks

TextMarks is a text messaging marketing platform prioritizing mass SMS communications. It also lets businesses create text campaigns for customers to text for more information or text keywords to garner a specific SMS action from your business. 

TextMarks’ offerings are suited for businesses in a wide range of industries, like real estate or event planning. Whether you want to enhance customer communications or build a solid lead generation system, TextMarks software could bridge the gap between your business and your audience.

TextMarks Health and Stability

TextMarks Inc. is a California-based company founded in 2007. It’s holding firm in the business texting market 15 years later, although its website still appears to be that old. Still, appearances aside, TextMarks earns over $206,000 of revenue per employee, with an impressive $6.5 million of annual revenue, according to Kona Equity data. 

The company’s downfall is that it lacks the transparency today’s customers rely on to make sound business decisions. There’s virtually no information about TextMarks as a company on its website, including who’s behind it and how it came to be, which differs significantly from competitors like SimpleTexting and Textedly.

Still, TextMarks’ overwhelmingly positive customer reviews and solid revenue data lead us to believe that its immediate future still looks promising. However, we aren’t 100% confident that longevity will be on its side as similar services edge ahead in transparency and modernity. 

TextMarks Pricing

One thing you may notice right away about TextMarks’ pricing is that it’s significantly more expensive than other services. However, it’s also designed for high-volume texting, so you won’t find more affordable options for modest business texting needs.

Get free setup for your TextMarks plan when you buy an annual subscription. 

TextMarks Pricing Structure

TextMarks offers two prepackaged plans and one custom plan. The prepackaged plans will likely include what most businesses need, like lead captures, mass texting, and SMS marketing. The primary differences between the tiers include the number of texts and keywords allowed, customized SMS flows, premium support, and custom reporting.

Prepackaged plans cost $549 per month for 35,000 messages and 20 custom keywords or $1,099 per month for 100,000 messages and 30 custom keywords. Large businesses might opt for a custom plan if they want dedicated support and onboarding to set up their accounts and access to unlimited messages and custom keywords. 

Plans also require a $199 setup fee before activating.

Subscribers can also contact the support team if they need to purchase additional message credits or custom keywords at any time. 

TextMarks Pricing Comparison

At a minimum, TextMarks charges $549 per month, and this pricing is likely out-of-budget for many small to mid-sized companies. Other services fit better into more modest budgets, like Textedly, with its lowest-tier paid plan costing just $24 per month when billed annually.

Of course, this Textedly plan includes only 1,200 messages compared with TextMarks’ 35,000, making it best for smaller companies with intimate customer bases. Still, a Textedly plan with 30,000 messages is close to $200 less than TextMarks at $350 per month, billed annually.

Alternatively, Sendinblue has a pay-as-you-go approach that might suit some companies better. A plan gets you 1,000 text credits free per month, but you can pay for up to 10,000 more for as little as $109. These credits roll over month-by-month without expiring.

TextMarks Trials and Guarantees 

TextMarks does not currently offer a free plan or free trial to test the system before buying. However, you can request a demo by contacting the support team. 

Waive the $199 setup fee when you subscribe to an annual TextMarks contract.

TextMarks Business Text Messaging Service Review

TextMarks gives businesses plenty of ways to get information into customers’ hands through convenient texting. Instant text responses and text-for-information campaigns can help you build a solid text marketing strategy to connect with customers.

TextMarks could be a good fit for businesses with mass text marketing needs, but smaller businesses may find it too costly. Read our review of the best business text messaging services to see how TextMarks compares. 

What Makes TextMarks Business Text Messaging Service Great

TextMarks SMS API
TextMarks SMS API lets businesses send outgoing and receive incoming text messages from customers through a speedy connection.
  • Relatively smooth learning curve: TextMarks is a simple system to set up and navigate, whether you use its cloud-based platform or set up your own API. The documentation included with your subscription is easy to follow, and customer support is readily available and responsive for extra assistance if needed.
  • Customer segmentation: TextMarks allows list segmentation so that you can target specific customer groups when needed. For example, you might want to track two different marketing campaigns using two keywords to evaluate their performances for optimization purposes. Segment your customers into two lists based on who signed up with each keyword to track your text marketing with those campaigns.
  • Helpful customer service: A common theme in TextMarks reviews is the excellent customer support users receive when they need help setting up or using their service. This includes thorough explanations and walk-throughs to navigate the system if needed. TextMarks is available through multiple contact methods, too, including phone, mail, email, and social media.
  • Works with virtually any industry: Businesses that use TextMarks are in various industries, from food and beverage to senior living, proving that virtually any business can benefit from using the service to connect with their customers. According to TextMarks, internal and external communications, construction, manufacturing, and healthcare are among the top industries that use the service. 
  • Scheduled texts: Schedule texts ahead of time to send when you need them to send automatically. With this feature, you can easily plan out your mass text marketing campaigns days or weeks in advance to prepare for upcoming events and promotions you want your subscribers to know about. 
  • Options for unlimited messaging: Even with the lowest TextMarks tier, subscribers can get up to 35,000 texts and 20 custom keywords per month. However, unlimited texts are available with a custom enterprise plan, differing from other services that cap you at a maximum number of texts each month.
  • Lead generation: Businesses can use TextMarks to gather customer information for lead generation purposes through simple texting with keywords. For example, you can advertise something like, “Text ‘INFO’ to 12121 to learn more” on your business card or billboard. When someone texts this keyword to the number, an automated response can ask for additional information to capture customer data. Or, send a link via text to prompt the person to fill out a form. 
  • Automatic responses: Set automatic responders with the TextMarks auto-responder feature. When someone texts you with a specific keyword, the auto-responder sends your premade message to the texter in response to that keyword. This feature saves your team from having to personally respond to texts that the system can handle.
  • Mass texting: Whether you want to send a mass promotional text to customers or alert your team of company news or events, TextMarks’ mass texting system makes it happen. The feature allows you to send texts to a whole group or single out specific people from that group, ensuring that you only send texts to the right people. When recipients respond, they can respond only to you rather than the whole group, depending on your mass texting settings.

Where TextMarks Business Text Messaging Service Falls Short

TextMarks mass text messaging
TextMarks helps businesses create massive text campaigns to better support their customers and marketing.
  • Lacks built-in integrations: TextMarks customers can build their own API using the TextMarks platform to integrate other third-party apps and tools. However, TextMarks doesn’t include many integrations on its own. To truly customize your TextMarks experience, you’ll need to have a developer on your team who knows how to customize the SMS API to your company’s requirements.
  • No online ordering: To start using TextMarks, you must contact the sales team by emailing or calling. Currently, there’s no way to order the package you want online on your own, which could be a turn-off for company owners who know what they want and don’t want to waste time speaking with sales representatives. Also, if you run out of monthly texting credits or shortcodes and want to add some to your plan, there’s no way to do so via your online dashboard. Again, you’ll need to contact sales.
  • Not best for small businesses: Small businesses can find much more modest texting packages elsewhere than with TextMarks. This company is designed for massive texting needs, with its smallest subscription package including 35,000 messages. In contrast, alternatives allow for as little as 500 messages per month.  
  • Pricey: Because it targets significant texting needs, TextMarks’ packages are much pricier than others, with a minimum subscription of $549 per month. When compared to other services with a similar number of texts, the cost is still more than average. 
  • Outdated website: A company’s website doesn’t necessarily have an impact on how its service works. However, TextMarks largely misses the mark on having a modern, user-friendly website that’s appealing to customers. It lacks the transparency that a lot of other companies have, including skipping out on information about the company and pricing details that could help business owners decide whether it’s the right choice for them. 

TextMarks Business Text Messaging Service Compared

SimpleTexting is our top suggestion for a business text messaging service for most businesses because of its simple interface that facilitates quick and convenient customer support and connections.

  • SimpleTexting – Best texting service for marketing and sales
  • Textedly – Best for bulk texting
  • OpenPhone – Best for unlimited calling and texting
  • Podium – Best for text-to-pay
  • Sendinblue – Best for texting combined with email services

Final Verdict

TextMarks could be a possible solution for large businesses with high-demand SMS marketing and communication needs. With plans that support unlimited messages, subscribers, and keywords, you don’t need to feel limited in your marketing efforts.

With that said, expect to pay for the service. TextMarks is pricier than other options, like SimpleTexting, which offers similar features and texting packages for more affordable pricing.

Posted on

397: User-Generated Content Saftey

I was asked about the paradoxical nature of CodePen itself recently. CodePen needs to be safe and secure, yet we accept and gleefully execute user-authored code, which is like don’t-do-that 101 in web security. Marie and I hop on the show to talk this through as an update from quite a long time ago. It’s wonderfully-terribly complicated. Part of what complicates it is that there are many different kinds of worrisome code, from malicious, to distasteful, to spam, and they all need different treatment. This is a daily and never-ending war.

Time Jumps

  • 00:27 Listener question
  • 04:09 Browsers have gotten safer
  • 06:18 Sandboxing
  • 09:31 Sound in the browser
  • 11:19 Sponsor: Notion
  • 12:21 It’s not always bad actors, but sometimes it is
  • 15:35 SEO spam
  • 19:27 The threat of Google blocking
  • 20:31 Tooling to stop bad behaviour

Sponsor: Notion

Notion is an amazing collaborative tool that not only helps organize your company’s information but helps with project management as well. We know that all too well here at CodePen, as we use Notion for countless business tasks. Learn more and get started for free at notion.com. Take your first step toward an organized, happier team, today.

The post 397: User-Generated Content Saftey appeared first on CodePen Blog.

Posted on

392: Project Management Refresh

Dee and Chris chat about our latest take on Project Management (PM), a somewhat tricky topic for us with such a small team where literally everyone is an individual contributor (IC) with a lot on their shoulders aside from PM.

We’re attempting a project of large scale, so part of what has helped us so far is scoping the project into phases releases. That way work that we know is in a later release can be put off until we’re literally working on that release. Without at least that prioritization, things would take much longer. The releases are also chunked into sub-projects with a no-too-little and not-too-big quality, and within those projects is where the kan-baning happens. If we can keep the whole team on one project (or at least a group of 2-3), it limits the context switching which also helps speed and productivity.

We use Notion for most of this work, and it’s been nice to keep literally all of it (all the way up through all the phases) in one big database, then we scope the views down to phases and projects and cards. Each card we make sure has a very actionable tone to it and includes everything one might need to finish the task, including decisions, previous conversations, relevant other tickets, etc. Each card has things you might expect like who is working on it, the current status, whether it’s blocked or not, and several other useful bits of metadata. It also contains time estimates, so we can, at a glance, see how far we’ve come and what’s left on any given project. We know things like time estimates can change quite a bit, but everyone is well aware of that and isn’t beholden to the numbers. It just gives us some idea of what is going on other than feeling like we’re entirely driving blind. Each week we take a look at the progress together as a team.

Time Jumps

  • 00:21 API follow up
  • 02:10 The topic: Project Management
  • 04:05 Why we need to manage our project(s)
  • 05:06 What did we do with Notion?
  • 11:03 Beta means database is safe
  • 11:55 How do we organize around projects?
  • 15:54 Sponsor: Split
  • 16:41 Alpha vs beta vs final
  • 22:43 What are the fields inside Notion we’re using?
  • 32:21 Connecting to GitHub as well

Sponsor: Split

This podcast is powered by Split. The Feature Management & Experimentation Platform that reimagines software delivery. By attaching insightful data to feature flags, Split frees you to quickly deploy, measure, and learn the impact of every feature you release. So you can safely deliver features up to 50 times faster and exhale. What a Release.

Start raising feature flags (and lowering stress). Visit Split.io/CodePen for a free trial.

The post 392: Project Management Refresh appeared first on CodePen Blog.

Posted on

391: Early TypeScript at CodePen

TypeScript ain’t exactly new, but it’s a bit new to us. Robert was the most knowledgeable about TypeScript on the team and felt like it could be valuable for us. What does that mean though? Where would we use TypeScript? What blockers were there? What does it actually help with? The implementation hasn’t been trivial, so has it been worth it? Will it be worth it? Robert, Chris, and Stephen discuss.

Time Jumps

  • 00:29 TypeScript in production
  • 02:47 Why TypeScript?
  • 08:51 Baby steps into TypeScript
  • 15:57 How it’s worked out
  • 20:00 Type vs Prop Types
  • 25:43 GraphQL, Go, and TypeScript
  • 28:37 Getting used to TypeScript

The post 391: Early TypeScript at CodePen appeared first on CodePen Blog.

Posted on

390: The Social Media Zeitgiest

Marie and I talk about what’s going on in the world of social media, and what that might mean for CodePen and front-end developers. Twitter doesn’t feel particularly healthy at the moment, but has been the biggest player for front-end developers for a lot of years. Are we moving? Not? Where?

Time Jumps

  • 00:14 Zeitgeist
  • 01:55 WTTwitter
  • 04:11 Frustration with Twitter
  • 06:55 Twitter is where you find out what’s happening
  • 09:34 Why are we talking about Twitter?
  • 12:58 Mastodon
  • 24:30 Going to Reddit
  • 27:37 RSS and blogging
  • 35:15 CodePen is social, but not a new Twitter

The post 390: The Social Media Zeitgiest appeared first on CodePen Blog.

Posted on

A Couple Changes Coming in Chrome 108

“A change to overflow on replaced elements in CSS”:

From Chrome 108, the following replaced elements respect the overflow property: img, video and canvas. In earlier versions of Chrome, this property was ignored on these elements.

This means that an image which was earlier clipped to its content box can now draw outside those bounds if specified to do so in a style sheet.

So, image, video, and canvas elements that were once clipped might display the overflow when Chrome 108 ships. The noted situations where this might affect your existing work:

  • The object-fit property is used to scale the image and fill the box. If the aspect ratio does not match the box, the image will draw outside of the bounds.
  • The border-radius property makes a square image look like a circle, but because overflow is visble the clipping no longer occurs.
  • Setting inherit: all and causing all properties to inherit, including overflow.

Worth reading the full article for code examples, but the solution for unwanted visible overflow is overriding the UA’s default overflow: visible with overflow: clip:

img {
  overflow: clip;
}

“Prepare for viewport resize behavior changes coming to Chrome on Android”:

In November, with the release of Chrome 108, Chrome will make some changes to how the Layout Viewport behaves when the on-screen keyboard (OSK) gets shown. With this change, Chrome on Android will no longer resize the Layout Viewport, and instead resize only the Visual Viewport. This will bring Chrome on Android’s behavior up to par with that of Chrome on iOS and Safari on iOS.

This is a change related to the common headaches of working with viewport units and fixed positioning on mobile touch devices. We’ve covered (and tried solving) it over the years:

The change means that Chrome on Android will no longer resize the Layout Viewport when the on-screen keyboard is shown. So, the computed values of viewport units will no longer shrink when a device’s keyboard is displayed. Same goes for elements that are designed to take up the full viewport no longer shrinking to accomodate the keyboard. And no longer will a fixed-position element wind up who knows where when the keyboard pops up.

This brings more consistent cross-browser behavior that is on line with Chrome, Safari, and Edge on iOS and iPadOS. That’s great, even if the updated behavior is less than ideal because the keyboard UI can still cover and obscure elements that get in its way.

If you prefer elements to remain visible when that happens, it’s worth looking at a solution Chris shared a long while back that uses the prefixed webkit-fill-available property:

body {
  min-height: 100vh;
  min-height: -webkit-fill-available;
}
html {
  height: -webkit-fill-available;
}

That uses the available space in the viewport rather than what’s covered by the UI… but Chrome currently ignores the property, and I’d bet the nickel in my pocket that it is unlikely to start respecting it in the 108 release. That may be a moot point, though, as Chrome 108 also introduces support for small, large, and dynamic viewport units, which are already supported in Safari and Firefox.

This browser support data is from Caniuse, which has more detail. A number indicates that browser supports the feature at that version and up.

Desktop

ChromeFirefoxIEEdgeSafari
108101NoNo15.4

Mobile / Tablet

Android ChromeAndroid FirefoxAndroidiOS Safari
No106No15.4

A Couple Changes Coming in Chrome 108 originally published on CSS-Tricks, which is part of the DigitalOcean family. You should get the newsletter.

Posted on

Need help with this python question

Write a python program to take 10 values from user. The values
are given below:
myValues = 3,6,7,9,3,6,8,3,5,10, 19,0,1,0,15
1. Print the sum of those numbers which are at odd positions and
the division of the even index numbers.
2. Remove the duplicate numbers and place some random number
between (20 to 30) instead of that number, and store in this way
that no one can edit these values later.

Posted on

388: Durable Objects

Robert and I jump on to chat about Cloudflare’s product Durable Objects. It’s part of their Workers platform, which we already use at CodePen a good bit, but with Durable Objects…

Global Uniqueness guarantees that there will be a single instance of a Durable Object class with a given ID running at once, across the world. Requests for a Durable Object ID are routed by the Workers runtime to the Cloudflare data center that owns the Durable Object.

In their intro blog post a few years back, they call the “killer app” real-time collaborative document editing, which is obviously of interest to us. So we’ve been tinkering and playing with how that might work with CodePen’s future technology.

Time Jumps

  • 00:25 What Robert’s been up to
  • 01:08 What is a durable object?
  • 02:52 Using Workers with durable objects?
  • 08:13 Sponsor: Equinix Metal
  • 08:51 How does clientside work with Workers?
  • 15:58 What if the durable object dies?
  • 19:47 Cost of durable objects

Sponsor: Equinix Metal’s Startup Partner Program

Equinix Metal’s Startup Partner Program helps early stage companies level up. Their experts work with startups like Koord and INVISV to build their competitive edge with infrastructure. Equinix Metal provides real time guidance and support to help startups grow faster. With up to $100,000 in infrastructure credit, access to Equinix’s global ecosystem of over 10,000 customers and 1,800 networks, they might just be what you need to take your startup global.

Visit metal.equinix.com/startups to take your startup to the next level.

The post 388: Durable Objects appeared first on CodePen Blog.