Guidelines on the interaction and content design of visual displays inside elevators

I found the question What makes the elevator experience so awkward? rather interesting, but for practical purposes thought it was better to focus on one aspect of the experience that designers have tried to improve by providing some visual displays inside the elevator.

I assume that due to the physical and technical design constraints, the position of these displays are located usually above the buttons for the floors inside an elevator (even though some elevators don’t have them inside) or on the wall near the entrance to the elevator.

Since it is impossible to determine the amount of time people may be waiting outside for the elevator, or the amount of time that they might spend inside the elevator, how do people determine what content is presented on these visual displays and how long contents are displayed before they are changed?

Guidelines for Material Card in Android

If I were to follow elevated card(first one) like here, where should I place the expand more arrow? Also, is it okay to do the same card with image on the left?

Cards displayed are different brands of the same product. So I feel a full rich media is too much?

The screen has multiple tab items cards like these for each tab. Any place I can get examples of similar card designs other than Thank you.

Accessibility Guidelines for saving changes to boolean controls in a web app

We currently have some settings pages in a web app where there is a list of controls with checkboxes, so you can enable/disable certain features. We also have a save option below these that is disabled until a change is made to the previous checkboxes.

We are trying to conform this form to be more accessible and the current approach is to simply not disable the save option, but throw an error if no change has been made and a success message on a successful change.

This doesn’t seem like it makes the form more usable but only helps to get around the accessibility rule that a submit button shouldn’t be disabled. However, from an interaction perspective, the affordance of the disabled look of a button lets a user know that their work isn’t complete.

There’s 3 possible solutions I’ve come up with for this scenario:

  1. Maintain a READ view of these controls where no action can be taken unless clicking EDIT to change the controls. in EDIT mode, the checkbox options are available as well as SAVE & CANCEL and **SAVE* would be disabled until a change was made (not sure if this passes accessibility, but at least makes the idea that you are “editing these fields and must save it” more deliberate).
  2. Style the button like a disabled button but use HTML to treat it like a regular button. If clicking the button, we can display a warning that states “You did not make any changes. Please change some controls in order to save”.
  3. Change the checkboxes to be a switch-style component that simply autosaves, which takes the “Save” button out of the equation.

If any accessibility inclined people have thoughts on which of these options (or some alternate that I didn’t think about) would improve the usability of this scenario while making it accessible, please let me know.

Writing GOlang object code that respects Go guidelines

Learning GO and I wrote this for a programming challenge. It is working (building and running) but I feel the code is not what GO code should be :

  • am I using the struct element correctly ? especially struct methods ?
  • in the playTurn() method, I reassign results (else not taken into account) because scope. How to write it better ? Pointer ?
  • I am struggling with int, float64 and casting all the time. What’s the good practice in this context were I need float for precision in-between but inputs and outputs are int ?

full script :

package main  import (     "fmt"     "math"     "os"     "strconv" )  // Pod is life type Pod struct {     position                Dot     vx, vy, angle, nextCpID int     hasShieldOn             bool }  func squaredDist(a, b Dot) int {     return (a.x-b.x)*(a.x-b.x) + (a.y-b.y)*(a.y-b.y) } func distance(a, b Dot) float64 {     return math.Sqrt(float64(squaredDist(a, b))) }  func (pod Pod) getAngle(p Dot) float64 {     d := distance(p, pod.position)     dx := float64(p.x-pod.position.x) / d     dy := float64(p.y-pod.position.y) / d     a := math.Acos(dx) * 180.0 / math.Pi      // If the point I want is below me, I have to shift the angle for it to be correct     if dy < 0 {         a = 360.0 - a     }     return a }  func (pod Pod) diffAngle(p Dot) float64 {     a := pod.getAngle(p)     pangle := float64(pod.angle)      right := 0.0     if pangle <= a {         right = a - pangle     } else {         right = 360.0 - pangle + a     }      left := 0.0     if pangle >= a {         left = pangle - a     } else {         left = pangle + 360.0 - a     }      if right < left {         return right     }     return -left }  func (pod Pod) rotate(p Dot) int {     a := pod.diffAngle(p)      // Can't turn more than 18° in one turn !     if a > 18.0 {         a = 18.0     } else if a < -18.0 {         a = -18.0     }      pod.angle += int(math.Round(a))      if pod.angle >= 360.0 {         pod.angle = pod.angle - 360.0     } else if pod.angle < 0.0 {         pod.angle += 360.0     }     return pod.angle }  func (pod Pod) boost(t int) (int, int) {     if pod.hasShieldOn {         return pod.vx, pod.vy     }     pangle := float64(pod.angle)     pod.vx += int(math.Round(math.Cos(pangle) * float64(t)))     pod.vy += int(math.Round(math.Sin(pangle) * float64(t)))     return pod.vx, pod.vy }  // t shoud become a float later on func (pod Pod) move(t int) (int, int) {     pod.position.x += pod.vx * t     pod.position.y += pod.vy * t     return pod.position.x, pod.position.y }  func (pod Pod) endTurn() (int, int) {     // todo rounding position if needed     pod.vx = int(float64(pod.vx) * 0.85)     pod.vy = int(float64(pod.vy) * 0.85)     return pod.vx, pod.vy }  func (pod Pod) playTurn(p Dot, t int) {     pod.angle = pod.rotate(p)     pod.vx, pod.vy = pod.boost(t)     pod.position.x, pod.position.y = pod.move(1)     pod.vx, pod.vy = pod.endTurn()     fmt.Fprintf(os.Stderr, "\nPredicted Pod position : ")     fmt.Fprintf(os.Stderr, "\n(%d, %d) speed (%d,%d)", pod.position.x, pod.position.y, pod.vx, pod.vy) }  // Dot is king type Dot struct {     x, y int }  func main() {     var laps int     fmt.Scan(&laps)      var checkpointCount int     fmt.Scan(&checkpointCount)     var checkPoints []Dot     for i := 0; i < checkpointCount; i++ {         var checkpointX, checkpointY int         fmt.Scan(&checkpointX, &checkpointY)         checkPoints = append(checkPoints, Dot{checkpointX, checkpointY})     }     var myPods [2]Pod     var itsPods [2]Pod     for {         for i := 0; i < 2; i++ {             // x: x position of your pod             // y: y position of your pod             // vx: x speed of your pod             // vy: y speed of your pod             // angle: angle of your pod             // nextCheckPointId: next check point id of your pod             var x, y, vx, vy, angle, nextCheckPointID int             fmt.Scan(&x, &y, &vx, &vy, &angle, &nextCheckPointID)             myPods[i] = Pod{Dot{x, y}, vx, vy, angle, nextCheckPointID, false}             fmt.Fprintf(os.Stderr, "\nActual Pod position : ")             fmt.Fprintf(os.Stderr, "\n(%d, %d) speed (%d,%d)", myPods[i].position.x, myPods[i].position.y, myPods[i].vx, myPods[i].vy)         }         for i := 0; i < 2; i++ {             // x2: x position of the opponent's pod             // y2: y position of the opponent's pod             // vx2: x speed of the opponent's pod             // vy2: y speed of the opponent's pod             // angle2: angle of the opponent's pod             // nextCheckPointId2: next check point id of the opponent's pod             var x2, y2, vx2, vy2, angle2, nextCheckPointID2 int             fmt.Scan(&x2, &y2, &vx2, &vy2, &angle2, &nextCheckPointID2)             itsPods[i] = Pod{Dot{x2, y2}, vx2, vy2, angle2, nextCheckPointID2, false}         }          // fmt.Fprintln(os.Stderr, "Debug messages...")         for _, pod := range myPods {             nx := checkPoints[pod.nextCpID].x - 3*pod.vx             ny := checkPoints[pod.nextCpID].y - 3*pod.vy             // Predicting where my pods will be next turn:             pod.playTurn(Dot{nx, ny}, 100)             //             fmt.Println(strconv.Itoa(nx) + " " + strconv.Itoa(ny) + " 100")         }     } } 

Is a designing UIs according to branding/design guidelines actually design? – job position

Point me to where I can post this if this is not the right place. I am new here, take it easy pls

I received an offer from a leading engineering company and I thought it was UX, involved research, brainstorming and coming up with new ideas, in addition to UI design.

However, after talking with someone who works there, she mentioned that it is a UI design job where I would be redesigning new screens and interactions almost completely based on the design guidelines built by another team.

How can this be considered a ‘design’ job? I think creative output or problem-solving is seriously lacking here.

Any thoughts from more experienced people on this kind of work?

Should we have our own guidelines or go for open source like Material Design?

I would like to have your valuable feedback on this topic. I work in a small French company which is into software intelligence. I am struggling to convince them to bring consistency in their products by having their own guidelines. Some of the key leaders are fine with Material Design considering the budget, resources and time. Some are not. They want to build their own library but in minimum time, with fewer resources, and making the reusable components.

Which technology should we prefer if we go with the 2nd option ( Creating our own Style guide). They are afraid of investing more time and which in turn would affect the business. On the other hand, they want to create a visual signature as well. What another open source library we can use apart from Material Design? Few people suggested Bootstrap templates. Those ways you can pull your favorite components and build a system. Isn’t it like building your own library in terms of time, resources. Would it be a reusable component and easy to maintain?

Thanks for the valuable time and comments. I really appreciate it.


Reactive streams guidelines, patterns and anti-patterns

This is a question about reactive / observable streams, MVI and similar. It’s a set of sub-questions, but I feel they are very coupled, so posting it as one question to capture the similarities.

I’ve been trying to learn concepts around this and I’ve run into several problems while doing that. Here are my observations:

  • Resources (articles, books, videos) are either too low-level (just discussing the API) or too high-level (how to connect two microservices). No discussion about the problems and solutions with using observables within a medium-size app

  • Examples are almost always toy examples with 1-3 streams. No discussion about the problems you face when you have 20 or 100 streams and solutions to those

  • Examples are also almost always static. Streams are pre-wired on startup. No discussion about the problems and solutions related to cases where streams come and go, managing subscriptions and such

  • There are many disagreements and contradictions. Some people suggest using subjects a lot, others suggest never using them. Some people suggest using streams everywhere, some only on the fringes of the system. Some are in favor of a lot of small events and streams, while others prefer coarse-grained structure

Questions arising from the above:

  • Are there medium-sized open-source apps built using reactive streams that I can look at to try to answer these questions myself?

  • Are there any resources that I missed provide answers to some of the questions above?

  • Do you have personal experience with either reactive streams or any other reactive system from which patterns / anti-patterns translate to reactive streams?

  • In general, is there a list of guidelines, patterns and anti-patterns when using reactive streams in medium-sized apps?

How to follow ios guidelines when designing in points? How to be sure about sizes of UI elements?

Good day to everyone,

Need help from very experienced UX designers, who can provide detailed answer here.

I have a few questions regarding the design process of an iPhone mobile app (daily task manager app to be exact). It should be an iPhone app supporting iOS version 9.

  1. General question: If we should provide mobile app design (in Sketch) for iPhone devices (Iphone 5S (320×568) render at 2x,6 (375×667) render at 2x,6+ (414×736) render at 3x), which have different dimensions and resolutions, what is the size (from the beginning) we have to start to work with when following good practice? Should I provide high fidelity mockup for any specific devices first, and only scale it down or up to other 1x sizes after? P.S.: When we want to handover files to the developer we will have to export in all @1x, @2x and @3x sizes. I know that Sketch will export my 1x design to 2x and 3x. But again the question is the same – should I design for 1x sizes for all devices separately – 1x size for 5S, 1x size for 6 and 1x size for 6+ first?

  2. I am working in Sketch 3. And I’ve been started with 375*667 points for @1x for iPhone 6 first. When I have to design for iPhones, I usually start with art-board of iPhone 6 at 1x (375×667 px). I found this more convenient than any other art-boards. When I am working in points, should I still abide by IOS Guidelines/Standards? I know that the general rule is 44pt for buttons and 12pt for small text, 17pt for body text and 20pt+ for titles. Why when I am working in points does the 44pt size seems to be a similar size for buttons as for segmented controls? It takes more space apparently. How can I comply with UI element sizes in such case? How are you following GUI standards when designing in points?

What are the industry guidelines on sharing secrets like API or access token?

I’m currently looking for guidelines on sharing API tokens or Access tokens securely, for integrating a third-party application with my own. The two methods I’m currently thinking of are:

  • PGP: I could share our public key with the third-party application owner, who could send us the access token for their API. However, from experience I’ve noticed the person on the other end is often not familiar with PGP and has neither the time or the knowledge how to sent via PGP properly.
  • Using an AES-256 encrypted zip over mail, and sending the zip password over another communication channel (e.g. in a text): This has the benefit of protecting the secret token from a mail compromise, and having a lower ‘technical threshold’ for third-party application owners.

I’ve looked for this in the NIST 800 guidelines without much success..

Are there other methods I’m overlooking, or is there an official source that can confirm these proposed methods as being the “industry standard”?