dropdown – Alternatives to cascading drop down interfaces

I don’t think that there is a better interface for what you are trying to do. First, like you have mentioned, this is the “classic” option – people have seen it and understand it, especially with your specific business case (selecting a vehicle model).

Second, the only real viable alternative to this is the “wizard” style control, which in this case is massive overkill because you are forcing the user to go through multiple pages just to select a single dropdown for each step. It is also less user friendly for that exact reason.

Depending on the number of options, you could test with select boxes (essentially dropdowns that show more than one item at a time and have an as-needed scrollbar) or radio buttons for each individual question. This might make the selection of the desired option easier, since it is easier to see what options are available, but this really isn’t that different of an interface from the standard.

discovery – Alternatives to Menu + Toolbar or Ribbon

The main application I’m working on has a very traditional (and boring) old school menu and toolbar, the toolbar indeed just a row of 16 small icons.

It has worked for us well over the years, but there are growing requests to put more features there, often “because it’s so good it deserves a button”.

It seems to be time to update the general look and feel, so before I start to clutter the toolbar I want to evaluate alternatives.

Issues

  • Discovery of some important but context – specific commands and keyboard shortcuts
  • Discovery of advanced operations that are currently “hidden” in context menus, or sometimes indeed just the manual
  • Dated look

Ribbon

I’ve tried to overcome my ribbon aversions and mock a replacement. I’m OK with the results, but they are a bit underwhelming and it will be hard to overcome “ribbon aversion” for our customers or even in the dev team. Issues/results here are:

  • A general impression of wasted space. Since we show a lot of data, this is relevant
    (incidentally, why are there no vertical ones?)
  • Tabs are not necessary most of the time, I’d likely end up with a main tab and one or two context tabs
  • I understand the motivation behind a “static interface, and largely support it, however, we do need some context sensitivity that sems to go against the concept (and maybe even the API). For example, we have a set of operations for a selected element, but they differ depending on the element – often slightly, sometimes more, often it’s a similar command but should naturally be a different icon. Showing all and disabling the unavailable would lead to clutter.
  • Quick Access Toolbar works very well out of the box, but the toolbar itself either “vanishes” in the title bar, or is another space-wasting band.
  • Good keyboard shortcut discovery (assuming we get it to work for non-ALT-keys, too)

Modern Menu + Toolbar

While I see different purposes – menu gives keyboard access to all commands, toolbar quick access to common commands with visual cues – they have grown together in looks and functionality over the years, so much that they look like a dead end. I particulary dislike the usually highly complex customization.

Some background

Roughly, the application is “toolbar, menu, navigation pane, and MDI area for many windows”. We have about ~60 commands total, a third deserves to be buried. In addition to that the chart windows have 10..20 depending on content, they are usually accessed through context menu and shortcuts right now.

Despite the complexity, we don’t have a “settings” dialog. There are a few options buried in context. (I found most option requests come from the devs themselves that want to offload a decision on the user. Asking “how woudl the user make that decision” kills most of them.)

We have some local toolbars (two common forms, and one of the navigation tree panels), they “feel” OK, but aren’t perfect.

Many products aimed at our customers expose a “three rows of toolbars with hundreds of icons constantly shifting” battlefield, customers are generally happy we don’t do that.

What do I want from you?

Ideas, inspiration, suggestion, experiences.

output formatting – MakeBoxes not allowing alternatives defined through variable

I’ve encountered an issue where using Alternatives(...) indirectly through a variable within MakeBoxes does not seem to work, and I was wondering why this might be.

As a simple example, consider the following:

altPattern = 1 | 2 | 3;

f1 /: MakeBoxes(f1(n : (1 | 2 | 3)), TraditionalForm) := With(
  {
    nText = Switch(n
      ,
      1, "one",
      2, "two",
      3, "three"
    )
  },
  RowBox({"Foo", "(", nText, ")"})
)

f2 /: MakeBoxes(f2(n : altPattern), TraditionalForm) := With(
  {
    nText = Switch(n
      ,
      1, "one",
      2, "two",
      3, "three"
    )
  },
  RowBox({"Foo", "(", nText, ")"})
)

As far as I can tell, both f1 and f2 should behave the same, yet Mathematica thinks otherwise:

output

Furthermore, the output from looking at the definition looks fine, with f2 using the altPattern as expected and f1 using the explicit form.

Furthermore, the issue seems to occur only in association with MakeBoxes as the following works fine:

f1(n : (1 | 2 | 3)) := 2 n
f2(n : altPattern) := 2 n

f1(1)  (* 2 *)
f2(2)  (* 2 *)

c++ – Alternatives for index arrays

I work on a C++ project where I am not really happy with the data structures. The question isn’t that specific to C++, I think that I would face a similar issue in say Java or Python.

There are data structures that have no direct relation in the code, although they have a 1-to-N relationship.

struct Element {
    int index;
    T payload;
};

struct Group {
    int index;
    T payload;
}

The instances are held in linear containers.

std::vector<Element> elements;
std::vector<Group> groups;

And then there is an index structure that relates them

std::vector<int> group_index_by_element_index;

In the code one sees patterns like that for access:

groups(group_index_by_element_index(element.index))

This doesn’t feel right, but I cannot put my finger on it. So I here are some alternatives that I came up with.

  • Alternative 1: I thought that one could instead change the element structure such that it contains a pointer to the group.

    struct Element {
        int index;
        T payload;
        Group *group;
    };
    

    Then one can just do element.group and has the associated group. The downside is that if the groups vector should ever be reallocated (resize, push_back), all the pointers would become invalid. In this particular case we can give an upper limit and just allocate enough memory right at the start.

  • Alternative 2: An alternative to pointers would be to use

    struct Element {
        int index;
        T payload;
        int group_index;
    };
    

    and access via groups(element.group_index).

  • Alternative 3: A different way to model the 1-to-N relationship would be to have

    struct Element {
        int index;
        T payload;
        Group *group;
    };
    
    struct Group {
        int index;
        T payload;
        std::vector<Element> elements;
    }
    

    and no global elements vector any more. Elements would have a pointer to their owning group, and there are no lifetime problems.

    This approach makes it harder to view all the elements at the same time, there is no single container with all of them. One would always have to loop over the groups and then loop over the contained elements.

    It doesn’t work if there is another 1-to-N relationship where the elements have different associations as with the groups. If the elements would be handles in batches, but each batch is mixed through the groups, I would either define the batch structure as holding Element * (dangerous with reallocation) or would store tuples of group and element indices. With the original approach, I could just add an index vector batch_index_by_element_index and would have it.

I see that the alternatives would give more concise code compared to the current version. Still I want to understand the motivations for the current state of the code. The independent index vectors make it easy to create new relationships between the various objects in the code. Also the index vectors don’t necessarily have to have to same scope as the element vector, allowing for local and fine grained relationships. Deeply nested data structures also seem to become a burden at some point, so having it flat appears easier, for some stage at least.

Are there certain patterns that I could look into to better understand which data structure would be good for the codebase at hand?

concurrency – Alternatives to pessimistic locking in the DBMS for load balancing

Even if not all accounts are equal, would you say that a random bucket sized group of accounts generate a roughly equal amount of work?

If so (and the stream of work is smooth enough) you can still use partitioning.

To address scaling the nodes: This is exactly what Kafka is good for. It will guarantee for you that work belonging to the same account will always go to the same node. (The same thread even). It will gracefully handle node failures, downtimes, new nodes for you. You can even explicitly listen to re-balancing events, but you probably won’t have to if you’re doing it right.

With Kafka Streams, you can basically just forget about all that and even can create stateful processing nodes with Kafka doing everything for you, including transfering the state if your nodes dies over to another node.

If you can’t use Kafka (you’re on Windows, or it’s just too complicated for the project) you can try to roll your own re-balancing. If your use-case is simple enough, you might be able to get it working in a couple of days. You’ll probably need something like Rendezvous Hashes, or something similar.

Any worth WhatsApp alternatives?

I think all of us already know about the latest WhatsApp privacy policy changes. And I'm sure that many already refused from that app. But what should we choose?

Signal so much promoted by Elon Mask faces troubles getting so many new users. Telegram can be deleted from Apple Store for its numerous channels they don't ban. Moreover, both of these messengers require a phone number during the registration, which is not safe also.

I've seen a Utopia p2p alternative…

Any worth WhatsApp alternatives?

collaboration – Evergreen alternatives to ideation workshops

I’ve participated in (and facilitated) ideation workshops. being event-based, they sometimes take quite a bit of time to set up, especially in bigger companies and teams. While they are great for brainstorming new out of the box ideas, I find that ideas often come at the most unexpected of times. My question is, does design thinking offer a solution for ideation that’s not event-based. more of an evergreen solution or platform where members can post their ideas related to a particular problem statement over a longer time window than a single event.