CodeIsGo.com

Kunyao Liu from Uber Engineering about their Customer Obsession Engineering team and how they designed and developed a new web application to help solve customer support tickets with aggregated data hydrated across Uber’s tech stack.

After considering multiple replacement hydration solutions, we landed on GraphQL, an open source query language for APIs. GraphQL can interpret the structure of our data sources and delivers only the information needed to resolve an issue, reducing throughput on our Customer Care Platform.

The article then dives straight in:

• Sourcing data
• Pain points in our old data hydration layer
• Why GraphQL?
• Integrating GraphQL with the Customer Care Platform
• Customer Care Platform architecture

Plenty of charts depicting their architecture together with resources to further reading. Watch this space as they also plan to add a query context cache through DataLoader, an open source data caching and batching utility available as part of the GraphQL stack. Great!

This session is part of a learning curriculum that author designed to incrementally skill up and empower a team of Designers and Researchers whose skillset and ways of working had fallen behind the times. By Robert Sens.

Why is Robert Seans sharing this? He has open-sourced this content to help others understand the fundamentals of human-centered interaction design and the multi-dimensional skillset needed to be successful in complex, collaborative environments.

Flows enables us to think spatially and visualize complicated systems from the perspective of an end-user.

When designing products and experiences, flows are the most powerful and multi-purpose tool to ideate and define impactful user experience. They help us:

• Understand – Processes, Relationships/Connections, Complexity, and the boundaries (of a system)
• Communicate – Everything mentioned above ☝🏼☝🏼☝🏼 [+] The structure of systems, Multi-step interactions, Why design decisions were made, Where opportunity exists
• Identify Opportunities – Customer Pain points, Gaps/Opportunity Spaces, Efficiencies, Inefficiencies

Plenty of visual flows in this article with links to further reading. Excellent!

Calendar controls, date pickers, date widgets, whatever you call them, however they are described, they follow the same basic principle – present the user with a calendar to enter a date (and sometimes a time). By Adrian Roselli.

The problem is that nearly every implementation of a date picker is a barrier for some set of users. I can comfortably say every one that I have seen is a problem, though perhaps there is a wonderfully robust one somewhere. Even the ARIA Authoring Practices, which is more comfortable with imperfect patterns, has not deigned to create a date picker.

The article describes author’s findings about usability and date pickers:

• Challenges – been testing with users for about 20 years (so far)
  • Accessibility
  • Validation
• An alternative to date pickers
  • Text field
  • Text field with messaging
• Places this will not work

There are plenty of situations where a plain text field (with or without the messaging feature I prototyped) will not work.

If you need to see chosen dates, unavailable dates, weekends, holidays, date spans, date ranges, dates where counts from start or end dates matter, and so on. Read this interesting post to learn more about accessibility challenged with input forms!

The third article by Eric Siron in a series about how to build a fully-functional two-tier PKI environment. This article to show you how to perform the most common day-to-day operations: requesting certificates from a Windows Certification Authority.

I want you to focus on the issuance portion. You do not need to know in-depth details unless you intend to become a security expert. However, you do need to understand that certificate issuance follows a process. Sometimes, an issuer might automate that process. You

The article then dives into:

• The PKI Certificate Request and Issuance Process
• Auto-Enroll Method
• MMC Enrollment Procedure
• Handling Certificate Signing Requests from a Linux System on a Microsoft Certification Authority
• Deprecated Web Enrollment Method
• Alternative Request Methods

In your own environment, you can utilize varying levels of automation. More automation means more convenience, but also greater chances for abuse. Less automation requires greater user and administrative effort but might increase security. Good read!

An article by Kevin Dangoor from Khan Engineering about how Khan Academy is embarking on a huge effort to rebuild our server software on a more modern stack in Go.

Ten years is a long time in technology! Academy chose Python as their backend server language and it has been a productive choice for them. Of course, ten years ago they chose Python 2 because Python 3 was still very new and not well supported.

While considering transformation they were also looking at the languages that have first-class support in Google App Engine. They considered Go and Kotlin. Kotlin is a very expressive language with an impressive set of features. Go, on the other hand, offers simplicity and consistency. The Go team is focused on making a language which helps teams reliably ship software over the long-term.

Finally, we ran a bunch of tests around performance and found that Go and Kotlin (on the JVM) perform similarly, with Kotlin being perhaps a few percent ahead. Go, however, used a lot less memory, which means that it can scale down to smaller instances.

The article then describes their journey:

• From monolith to services
• Cleaning house
• What’s not changing
• The plan

Good read with some interesting observations! Links to more articles with academy experience included.

This is a long overview of bunch of search engines and their architecture. By Tech & Cliqz on 0x65.dev.

It is important to understand that a web scale search engine is highly complex. It is a distributed system with strong constraints on performance and latency. On top of that it can easily become extremely costly to operate; both in human resource and, of course, in money.

This article explores the technology stack we employ today and some of our choices and decisions, which have been taken and iterated upon over the years, to cater both external and internal users.

The article contains multiple sections:

• Our search experience—dropdown & SERP
• Fully automated and near real-time search
• Deployments -— a historical context
• Intricacies of a search system
• Docker containers and container orchestration system
• Local development with tilt—an end to end use case

… and much more. This really is an in depth article, with plenty of references to open source software used, tooling and further reading. Really great!

Over a decade ago, it was a common practice to host server software on dedicated private servers. In the age of cloud computing, this hasn’t changed a lot because many businesses continue using cloud services as usual servers. By topal on hackernoon.

The article explains how you can use Google Cloud Platform free tier benefits during various phases of your startup lifetime:

• 4 options to host your application
• Google Cloud Platform free tier benefits
• Google Cloud Platform for startups
  • For startups before traction
  • For startups getting traction right at the moment
  • Post-traction startup growth

The article also does a good job explaining various options depending on your type of application, e.g. static website hosting, ReactJS single page application hosting, WordPress site hosting or best options for hosting REST APIs. Great advice!

With TypeScript 3.4, const assertions were added to the language. A const assertion is a special kind of type assertion in which the const keyword is used instead of a type name. By Marius Schulz.

TypeScript has a special kind of literal type that’s known as a non-widening literal type. As the name suggests, non-widening literal types will not be widened to a more generic type. For example, the non-widening string literal type “GET” will not be widened to string in cases where type widening would normally occur.

The article dives straight in:

• Motivation for const Assertions
• String Literal Types
• Literal Type Widening
• Non-Widening Literal Types
• const Assertions for Literal Expressions
• Using TypeScript Enums
• const Assertions for Other Types

Plenty of code examples in this to the point article!

Often we talk about value and we mean “financial value” a concept that can be measured in dollars and cents or pounds and pennies or whatever currency is near to hand. However, financial value is not the only motivating factor for users and consumers to invest in a product. In fact, it is the perception of value both financial and non-financial that drives the decision to adopt (or not) a product.

It’s often said that it’s important to give a user what they need through product design and not to examine wants at all. It is true that if a product fails to meet a user’s needs – they are unlikely to find it useful and thus, unlikely to adopt it.

The article then explains:

• Needs, wants, demands
• Perception of value – four concepts of value
• Engaging with perceived value
• What value is enough value?

The more value a user perceives in a product compared to its cost; the more likely they are to adopt that product in their lives. Good read!

The blog post by Haoyi about type safety equality in Scala. If you are doing something non-trivial to compute a trivial result, it’s probably an programmer error. Universal equality is just one common case of that.

The Scala language, following its Java heritage, allows you to compare any two values for equality regardless of their respective types. This can be very error prone, since a refactor that changes the type of one of your values may silently result in an equality check that can never return true.

This blog post explores how a “safer” equality check is just one of many features that go against the principles that underlie any type system with subtyping, and achieving it requires a fundamental re-thinking of what it means to be “type safe”.

The article then dives into:

• What are Types and Subtypes?
• The Liskov Substitution Principle
• Strawman: Exact-Type Matches
• Existing violations of Liskov
• Safety beyond Liskov Substitution
• What makes a trivial expression?
• What about Constant Folding?

The traditional definition of type-safety, based on types, subtyping and LSP, is deeply ingrained in almost all statically-typed languages. It allows us to prohibit at-compile-time anyone accidentally trying to perform an operation on an expression which might not support it. However, LSP says nothing about another type of issue: that in which a programmer writes code with trivially known results, which is likely to indicate an error or oversight.