## readability: to what extent is the blank text on a medium to light gray background objectively a bad practice?

I made the mistake of openly criticizing a web page because they asked me for an opinion. I ruled negatively. To what extent is the designer guilty of my unfavorable criticism?

Legibility judged objectively?

Here intrinsic and external factors intervene, such as monitors and eyes.

The small text, from 8 to 10px, white, in a solid tone of gray, which is somewhere between 10 and 35%, still made me fall a "star" … probably because the LCD helped me. The viewing angle of the screen, the density of pixels, maybe even the reflection of the screen could have influenced me. However, am I to blame or is this supposed to be avoided?

Since I have a slight astigmatism, I should not appreciate small sources that are too thin or light. But actually I use this configuration at this time for my desktop environment, with supbixel processing enabled as a necessity to render the font correctly, it is very thin. I'm not blind

Is it sustainable that one should not have to weigh such external factors, if one adheres to good practices, as a greater contrast between the text and the fund?

There was also no real need to choose such a clear gray. What finally gave me the impression of being careless, while the author could have tried to keep things warm and cozy with his choice of colors.

Relevance issues

The thing is that the user is not reading a poem with this configuration. I'm talking about the menu items that will only be read really until the user learns instinctively in the third word of the row.

Personally, I think readability is important. But good practices are not rules and I can not penalize the author because he violated Article X. Is this still somehow objectively A misstep from a UX perspective or is it rather that I was prone to simply "finding fault" subjectively, frustrated by not being able to read some words at a glance? To what extent is the white text on a light gray background objectively a bad practice?

Bonus question in the same line:

This menu was also hidden unnecessarily from the view, until it was invoked by a click. This superfluity made me fall another star, since it gets in the way of efficient interaction. Except, it's just an additional click. However, making a furore in the dynamics for the sake of having dynamics can be done without getting in the way.

The same question. Did I hold a valid resentment? Should the author get it or rather be offended?

## Is it a common practice to give a user a non-modifiable password?

Then I received an email with a password (ten characters as an automatically generated password) and this tip:

Note that passwords are case-sensitive. [website name] handles
sensitive information on behalf of some of its members and others
Organizations To help protect your data, we automatically assign
secure passwords To maintain this security, you can not change

This was something I had never seen before and leaves me with many doubts about the reliability of the website. I expected at least the ability to change the password.

## Game history: How did Immortal box set campaigns work in practice?

At the end of a long campaign, the PCs of my group of players ascended to immortality. Since I had a copy of the set of Immortals in the box, I tried to continue the campaign using those rules and almost immediately I threw in the towel. In my opinion, there were many confusing elements of that set of rules, but some of the biggest gaps related to the fundamental structure of the campaign, such as: What are the objectives and limitations of the characters? What are the time and space scales involved? How does a campaign narrative work, if players can decide at any time to take a century of downtime to touch up their half-planes at home? The published module I had at that time did not clarify most of these problems; took a lot of PC railroads through actions that did not seem to have a motivation to participate, and "challenges" that could also be avoided (wandering monster on the Astral plane, a lich and its environment: why would they participate? somehow with the wandering monsters at this point?).

How were the immortal level campaigns executed, in practice?

## SQL Server: bad practice to return more columns than necessary

Unfortunately, I have a fairly broad question regarding queries that return more columns than they need.

In short, is this bad practice and should be avoided at all costs? We continually have discussions about this in our development team. Some argue that all queries should only return the exact data they need, since this would reduce I / O, etc., others argue that it is OK to have a query that returns some additional columns such as int or nvarchar (50), since this reuses the execution Plan and accelerate the development. We are not using any SELECT statement * anywhere, so it is not a problem, it is simply where some additional columns are explicitly specified.

I know that this can trigger a debate instead of an answer, but any information would be useful.

## Design patterns: the best practice to create a landing page for a product that has many features (tools)

My web projects have 16 different features (tools). I divided these characteristics into 2 different groups, entrants, companies.

As we all agree, we must show UVP, the main benefit of the product for visitors on the landing page. So that it is not complex. In my case, all the different tools have their own UVP, and they also share common goals. I dont have a problem with that.

I do not think that all the tools are shown as 1 section on the destination page, since the user will get bored on a long page.

I'm trying to find the optimal solution. These are my findings so far.
We await your suggestions. Especially it would be great if you could show me real examples.

– I can create 2 header menus with names of plans (for beginners, for companies), when the menu is displayed and small features of the products are shown in the MEGA MENU. The home page will only include the main UVP, lead form, etc.

– Another option is to put all these features in a tab menu on the landing page. So that people can click and see the product summary, click on the button redirect to a specific page for more details.

– The last option is to have a vertical slider.

## How relevant are the theoretical convergence rates of convex optimization in practice, when the parameters are unknown and the function can be non-convex?

There are many known theoretical results about convergence rates for several convex optimization problems (possibly stochastic). For example, the popular review on optimization algorithms for machine learning. [https://arxiv.org/abs/1405.4980] It gives many results so rigorous.

For example, let's say we have a set of restrictions with diameter $$R$$, and we have stochastic access to an objective function with gradient estimates limited by the upper limit $$G$$. Then, one can rigorously prove that the projected SGD, with appropriate step sizes, converges at a speed $$O (RG / sqrt {T})$$.

I wonder how relevant theoretical results like this are in practice, where the relevant parameters may be unknown. In the previous example, the SGD step sizes must be chosen prudently (as functions of $$R$$ Y $$G$$) to reach the demonstrable convergence rate. But, let's say that my optimization problem is really complicated and not convex, and I execute an SGD algorithm on it. Let's say I start SGD in some convex region that contains a local, remote minimum $$R$$ of the true optimum. However, my algorithm does not know what distance is. $$R$$ of the optimum. Also, you may not know a priori a limit $$G$$ in the gradient estimates that I receive. In practice, I can still execute an SGD algorithm and converge to the optimum at a speed $$O (RG / sqrt {T})$$?

The previous paragraph is a specific example, but in general I am curious about how well demonstrable convergence rates are transferred in practice to complicated non-convex optimization problems (where, for example, one is satisfied to converge to any local precision minimum or high).

## python – Recommended practice for sending notifications with Django channels

I have a project in Django that uses Django channels. I use the Django channel to send notifications to users who are subscribed to article changes (add / edit / delete comments on the article).

So I chose this embodiment: each group of channels is an article and, when changes occur, the script sends a notification to the relevant groups. My code works correctly, but I have some doubts about whether the choice of the embodiment is the most appropriate for this task. I need advice, what is the best practice in my case?

Solution:

consumers.py

``````from channels.generic.websocket import AsyncJsonWebsocketConsumer
from channels.db import database_sync_to_async
from project.apps.account.models import UserStatus

async def connect (self):
await oneself. to accept ()
if it is not self.scope['user']is anonymous
groups = expect database_sync_to_async (self.get_users_subscription) ()
awaits database_sync_to_async (self.change_user_status) (True)

for group in groups:
& # 39; article_ {0} & # 39; format (group.article_id),
self.channel_name
)

async def receive_json (self, content, ** kwargs):
command = content.get (& # 39; command & # 39 ;, None)
article_id = content.get (& # 39; article_id & # 39 ;, None)
if command == & # 39; subscribe & # 39;
awaits auto subscribe (article_id)
elif command == & # 39; unsubscribe & # 39 ;:
wait for yourself to subscribe (article_id)
plus:
await self.send_json ({
& # 39; error & # 39 ;: & # 39; command unknown & # 39;
})

async def disconnect (self, code):
awaits database_sync_to_async (self.change_user_status) (False)

wait for self.send_json (action)

Async def subscribe (self, article_id):
& # 39; article_ {0} & # 39; format (article_id),
self.channel_name
)

async def unsubscribe (self, article_id):
& # 39; article_ {0} & # 39; format (article_id),
self.channel_name
)

def get_users_subscription (self):
user = self.scope['user']
)

def change_user_status (auto, online):
returns UserStatus.objects.filter (
user = self.scope['user']
) .update (online = online)
``````

views.py

``````from .notify import send_comment_notification

CreateComment class (CreateView):

...

def form_valid (self, form):
...
super () form_valid (form)
send_comment_notification (& # 39; create & # 39 ;, article_id)

UpdateComment class (UpdateView):

...

def form_valid (self, form):
...
super () form_valid (form)
send_comment_notification (& # 39; update & # 39 ;, article_id)

DeleteComment class (DeleteView):

...

def delete (self, request, * args, ** kwargs):
...
send_comment_notification (& # 39; delete & # 39 ;, article_id)
``````

notify.py

``````...

channel_layer = get_channel_layer ()
group_name = & # 39; article_ {0} & # 39 ;. format (article_id)
async_to_sync (channel_layer.group_send) (
Group name,
{
& # 39; Type & # 39 ;: & # 39; send.notification & # 39 ;,
& # 39; data & # 39 ;: {
& # 39; action & # 39 ;: action
}
}
)
``````

## What is the best practice of the B2B email dimension?

The ideal width of marketing emails is 600px. Does it also apply to business product emails? Or can it be sensitive without any maximum width limit?

## Extending for the function (also known as mixing) in Scala is a bad practice, is not it?

In Scala, sometimes the class extends a trait to provide some methods for inside class that extends

Scala test

``````import org.scalatest._

The ExampleSpec class extends FlatSpec with Matchers {...
``````

The tracker feature provides the following useful method such as startWith, endWith, and include

``````string should start with ("Hello")
chain must end with ("world")
string must include ("seven")
``````

The problem is simple, "`Specification example` It is not `Matchers`"
Extends for basic OOP functions.
This extends the confused code reader and the newcomer.

I think we should use `to import` I like it `import scalatest.matchers._`.
This does not stain the inheritance tree.

Please let me know what you think.

## java – Best coding practice: Declare a variable or use it directly?

This is the code

``````List listOfData = DAO.getInstance (). findbyId (Id);
listOfDataBos = BoHelper.wrapList (listOfData);
``````

Here we are creating a reference and then passing it to the wrapping function. Is there any harm in creating additional references here, as long as the reference is not used anywhere after this? I thought it provides better readability. Or is it better to write like this:

``````listOfDataBos = BoHelper.wrapList (DAO.getInstance (). findbyId (Id));
``````