ServerHub: Bizarre Billing Practices

Long time no publication. I just wanted to let everyone know in case they decided to use ServerHub for VPS services that apparently … | Read the rest of

blog – Best practices for caption text for images

More important than typography, size and style is the use of blanks. You should ensure that your readers know that this text belongs to the image as a subtitle. You can try 2em between the image, its narrow subtitle and the surrounding text, and see if the effect of the subtitle belongs or not to the image.

From what I've seen, subtitles are generally 80% (0.8em) of the body text size. But when you reduce the size of the text, it is more difficult for users to read it. And that is an impact on readability. Having a second style change with italics would exaggerate the effect you are looking for. Reduce the size Or make the text italic.

The meaning of italics is often to emphasize the word or phrase. When you reduce the text size, you send the message that this text is less important. Decide what message you are sending, before making a change in style or size.

What are the best practices for email subject lines?

What are the best practices for email subject lines?

Website design: best practices for asynchronous user experiences?

Can anyone suggest some good examples and resources to design asynchronous user experiences?

I am working on a web application that needs to process invoice shipments asynchronously to improve the user experience. We want to allow you to send an invoice, receive comments that it has been received and process it asynchronously in the back-end. Current synchronous presentations require a lot of processing and can take up to a couple of minutes or more due to integration with another system. It has not occurred to me that waiting 1-2 minutes in a web user interface is horrible.

Note: We can perform enough validations to reduce the possibility of shipping errors, but there will still be a small chance of errors.

I am looking for real-world examples of asynchronous user experiences to process where it is done well. For example, I know that does this to process orders. You will receive an almost immediate response that your order has been received, but is pending processing. There is still a small chance of a problem out of stock or some other problem. They communicate it via email notifications and in the user interface.

Users often send multiple invoices in the same session, so we want them to be able to send invoices one after another quickly in a way that:

  • Make it clear that the shipment was received, but more processing is required.
  • Surface errors clearly
  • Improve speed perception
  • Provide a more natural and improved UX workflow.

Any specific example or resource for this type of UX topic is greatly appreciated.

javascript – "alert", "confirm" and "warning" are considered bad practices?

When I work, some professionals do not like to use these functions and say that they are considered bad practices and that other more experienced programmers have warned them not to use and end up replacing these functions with modal windows.

My question is, if they were right about it, should we avoid it? Is it better to use the modal window to perform these operations?


alert("I am an alert box!");

function myFunction() {
   var txt;
   if (confirm("Press a button!")) {
            txt = "You pressed OK!";
   } else {
            txt = "You pressed Cancel!";
   document.getElementById("demo").innerHTML = txt;

c # – Microservices, controllers and .Net Core models: best practices for REST communication

We have 20 services in our company, implementing a micro services architecture with .Net core.

Now, services communicate with each other through REST. Let's call Service A – Payment Service and Service B – Customer Service.

There is no data shared between them.

At the moment, the current implementation is to create specific models and controllers for both services, and they communicate through the same models (POCO)

Example: PaymentService has a client request to deliver a report. PaymentService requires information from the CustomerService and calls a controller created specifically (in CustomerService) with the same Little-request for response. This is the implementation for each new implementation and communication request.

What would be a viable implementation of communication between services with REST?

best practices – Mysql Sharding. Application layer vs Mysql Layer

I'm going to create snippets in the mysql table and I'm stuck in a dileman either to search for application layer fragments or let Mysql handle it.
I mean, if I should find out which fragment to go and query on the application layer or pass the query to the Mysql controller and let it decide.
I read about some pros and cons of both [enter the description of the link here1 but I can't come to a conclusion.

My personal opinion is to go for the Mysql driver that handles it. Open to discussion about this.
Please share your opinions / experiences on the same.

Test online with best practices of 80 questions

When using a long form, you must use several methods to make a good user experience. For really long forms with many questions, here are several things you can try:

1. Group your questions into sections

Order your questions into manageable pieces. When you have a long form, you are likely to ask questions about many different topics. Its objective is to identify what these topics are and classify your questions into easy to understand sections.
Once you have sections, this means that you can more clearly assign where a person is in the process of completing the form. Completing sections also allows small rewards in a long and probably not fun form filling process.

2. Make the location visible

A key difference between short forms and long forms is that they require a different user experience. Short forms are completed in a couple of minutes, long forms can take hours, and people are expected to take breaks between sessions. For long forms, you must include a "you are here" feature, which keeps the person oriented and at the same time gives you the ability to estimate how much time you have left.

To make the location visible, you want to show where the person completing the form is in the process. You can use a percentage to complete the icon, page numbers, bread crumbs, loading bars, step by step, etc. There is no standard reference design for this, you will need to find a system that works with your form. In your case, I think this 2-level tree indicator is fine. interaction

3. Set expectations before the start

To prepare the person to start the form, give as much context as possible. This will increase the completion rates for people who begin the process.
The questions that an introduction could answer are:

  • Why is the person completing this form?
  • How long should it take to complete the form?
  • What is the schedule for the next steps?
  • Do they need to prepare something in advance (for example, have a driver's license on hand or prepare documents)?
  • What about the information they provide?
  • Who has access to it, how will it be used, how does it meet the privacy standards?
  • Does completing the form cost money?
  • Don't surprise people in the end with the cost.

4. Save each question automatically

When the user fills out a long form, some problems may arise. Connection problems, session expiration, etc. Make sure that all user steps are saved and do not need to be completed again.

5. Don't ask out of focus questions

Just hide the out of focus questions surrounding the focused question for very short forms. This design is good for a simple form such as a survey but bad for long online forms with many questions.
When I complete a form like this, I can feel that my heart rate increases because I am trying to find out if I am being tricked into thinking that the form is shorter than it really is.

This style of reducing opacity for out of focus questions is not accessible. People will inevitably feel that they should read the text out of focus before it is focused. But, because the colors of the text on the screen do not meet contrast accessibility standards, readability is reduced causing any difficulty for the person trying to read the question out of focus if they can even see it in the first place.

hide other questions

SEO best practices for multi-language domains

The best approach here would be to use folders (approach 1) to implement this on your site (this is done by many companies).

One of the problems with the subdomain approach is that the Domain Authority of the primary domain is not forwarded to the subdomains, so you would lose many SEO benefits that your domain could have gained over time.

And if you follow the third approach, you will also have the same problem of not obtaining SEO benefits as well as being very expensive to buy and maintain multiple domains.

Can abstractions and good code practices in built-in C ++ eliminate the need for the debugger?

Debuggers, although they are a useful tool for many things, are, by definition, primarily to … eliminate errors. Therefore, your question comes down to whether good practices and trust in the third party code can completely eliminate errors.

(…) trusting that the choice of language and good practices reduce the probability of errors, which eliminates the need for the debugger.

As you said, even if you trust that your languages ​​/ frameworks and good practices make mistakes less likely, you haven't removed all errors, but reduced the probability of their occurrence. Without a debugger (or some similar approach, such as registration), how will you diagnose those errors that still occur?

Also, if everyone trusts their languages ​​and frameworks 100%, how will the defects be discovered in the languages ​​/ libraries themselves? Open any conventional project on GitHub and see how many problems are reported.

Good practices can certainly reduce software flaws, but even best practices and tools will never eliminate the utility of a debugger.

I think your answer is in your own comment:

(…) many of my problems are encountered when the hardware shows unexpected behavior

The problem with mistakes is that we never see them coming.