Are there any guidelines or best practices for the design of multi-monitor systems?

By multi-monitor I mean systems which arrive out of the box with several physical monitors, each with predefined functionality. These are usually industrial systems running their own software.

This type of systems raises interesting questions, such as – do we duplicate important stuff on all the screens? Do we gray out all screens to display a modal dialog on one of them? Do we create a hierarchy of screen “importance” or are they equal? Etc.

There is some research on this from the ergonomics perspective but I’m looking for more of a UX-oriented work.

Are there any guidelines in place governing the extent to which magic items can resize to different-sized users?

Are there any guidelines in place governing the extent to which magic items can resize to different-sized users?

The description given under “Wearing and Wielding Items” (DMG, p. 140) says:

In most cases, a magic item that’s meant to be worn can fit a creature regardless of size or build. Many magic garments are made to be easily adjustable, or they magically adjust themselves to the wearer. Rare exceptions exist. If the story suggests a good reason for an item to fit only creatures of a certain size or shape, you can rule that it doesn’t adjust.

Going by this, it’s possible that upon the party defeating a fire giant wielding a magical greatsword, the halfling in the party could go touch the massive weapon, and it would shrink down to the size of a regular sword within seconds, given that there are no stated limits. I know that a DM can decide the extent to which this can happen to fit his/her own game, but is there any standard or given ‘Rules as Intended’ governing how this should be handled?

Secure coding standards and guidelines

I was trying to research on available secure coding guidelines of server-side and client-side languages.

There are online documentation from Oracle for Java, Microsoft for, and w3 for html5 to name a few. THere were also third wender guidelines from SEI, Veracode etc


For secure coding should non-vendor documentation like Veracode needs to be followed?

will the parent vendor documentation (like Oracle, Microsoft, etc) lacks any security guideliness from third vendor publications like veracode.?

Does all scripts/programming languages has secure coding guidelines available? is it mandatory

Guidelines for developing search engine

I’ve been asked to research the redevelopment of a university search engine. The existing search engine looks for students and how much funding they have through by way of a grant.

The existing search engine is an expert system that has about 40 fields. Users typically only need 4 or 5 fields but these can vary depending on the task.

I’m approaching this by building a basic prototype which I’ll use to drive out deeper needs from users.

But my question is this: is there any specific guidelines or evidence that would help me build a good search engine? What things should I be looking to build? What features?

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?