If you find yourself wrestling with CSS layout, it’s likely you’re making decisions for browsers they should be making themselves. Through a series of simple, composable layouts, Every Layout will teach you how to better harness the built-in algorithms that power browsers and CSS.

It’s a good practice to go through years’ old photos now and then, review the collection again with the current mindset, and post-process a photo or two from the pile. As experience expands with the time and number of clicks, the definition of a killer photo also evolves. You will be surprised to see an entirely different photo rendered every time compared to what you had in your mind when you pressed the shutter release button.

Tonya Dalton:

While the theory behind the Pomodoro Technique is solid – giving yourself focused, intentional blocks of time to dive into important work is extremely powerful – the problem is that the times are way too short. Research proves it takes an average of 23 minutes to get into our deep work zone where we are doing our best work. With the Pomodoro Technique, you interrupt yourself with a break just as you’re getting into that deep work zone.

Want to access community-driven repositories of cheat sheets with the shell command? cheat.sh is the tool you are looking for. Fire up your terminal, and run curl cht.sh to start exploring cheat sheets maintain by various development communities. The command will provide a concise and comprehensive response to your queries instead of dumping multiple search results at you.

cheat.sh usage is pretty straight forward. Follow the query format:

$ curl cht.sh/{language}/{your query}

For example, if you want to refer cheat sheet of posting a JSON request in Go, command to query the cht.sh will be:

$ curl cht.sh/go/post-json

And similarly, for C#, command will be:

$ curl cht.sh/csharp/post-json

This tutorial introduces the reader to the JWT (JSON Web Token) authentication in an ASP.NET Core 2.2 API through creating a simple example application.

There is, unfortunately, no shortcut key available to toggle between showing and hiding files or folder in the File Explorer. Hence this AutoHotKey script. You can toggle the view in File Explorer to show or hide with the just a Win+h shortcut key.

This script is not that fancy, it just toggles between two different values of the specific registry key and will send F5 keystroke to refresh the view in File Explorer.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

SetTitleMatchMode, 2
#IfWinActive ahk_class CabinetWClass
#h::
  RegRead, HiddenRegValue, HKEY_CURRENT_USER, Software\Microsoft\Windows\CurrentVersion\Explorer\Advanced, Hidden

  if HiddenRegValue = 2 
    RegWrite, REG_DWORD, HKEY_CURRENT_USER, Software\Microsoft\Windows\CurrentVersion\Explorer\Advanced, Hidden, 1
  Else
    RegWrite, REG_DWORD, HKEY_CURRENT_USER, Software\Microsoft\Windows\CurrentVersion\Explorer\Advanced, Hidden, 2

  WinGetClass, CabinetWClass
  Send {F5}
  return
#If

If you don’t prefer the above script, you can still toggle hidden items with the combination of multiple keystrokes in File Explorer. The key combination is Alt+v hh.

Designed by Hasan Kaymak

Look stunning! They should hire this person instead.

Leslie Richardson on not so commonly used attribute DebuggerDisplay:

By writing DebuggerDisplay syntax at the top of a class, you can choose what strings and properties you want at the top of each object node in debugger windows. Besides displaying strings in debugger windows, adding curly brackets ({}) to the DebuggerDisplay attribute allows Visual Studio to display the value of a property or method that you specify.

I attempt to create a small console application below to follow the usage of DebuggerDisplay.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

using System;
using System.Collections.Generic;
using System.Diagnostics;

namespace ConsoleApp
{
  [DebuggerDisplay("{LastName}, {FirstName}")]
  public class Worker
  {
      public int Id { get; set; }
      public string FirstName { get; set; }
      public string LastName { get; set; }
      public string Address { get; set; }
      public string City { get; set; }
      public string State { get; set; }
      public string Zip { get; set; }
      public string Phone { get; set; }
  }

  class Program
  {
      static void Main(string[] args)
      {
          List<Worker> workers = new List<Worker>();

          List<Worker> workers = new List<Worker>();
          workers.Add(
              new Worker {
                  FirstName = "Michael",
                  LastName = "Springer",
                  City = "Atlanta",
                  Phone = "001-232-1233"
              });
          workers.Add(
              new Worker {
                  FirstName = "Lloyd",
                  LastName = "Bever",
                  City = "Fort Myers",
                  Phone = ""
              });
          workers.Add(
              new Worker {
                  FirstName = "Vincent",
                  LastName = "Covey",
                  City = "Chester Heights",
                  Phone = "888-232-1233"
              });

          Console.WriteLine(workers.Count);
          Console.ReadKey();
      }
  }
}

You can also use nq (no quote) specifier if you don’t prefer to see quotes in debug values.

1
2
3
4
5
6

  [DebuggerDisplay("{LastName, nq}, {FirstName, nq}")]
  public class Worker
  {
    //...
  }
}

You can further extend DebuggerDisplay if you want to include an expression in debug values. Just add a private method or property in the target class, and provide that method or property to DebuggerDisplay.

1
2
3
4
5
6
7
8
9

[DebuggerDisplay("{DebuggerString(), nq}")]
public class Worker
{
  private string DebuggerString()
  {
      return string.Format($"{FirstName}, {LastName}. Has Phone: {!Phone.Equals(string.Empty)}");
  }
  //...
}

Ankur Anand has written an in-depth blog post to explain how memory management work in Go.

… the general idea of the Go memory management is to allocate memory using different memory structures using different cache level memory for objects of different sizes. Splitting a single block of consecutive addresses received from the operating system, into a multi-level cache improve the efficiency of memory allocation by reducing the locks and then allocating memory allocations according to the specified size reduces memory fragmentation and facilitates faster GC after the memory is released.

GoReplay is an open-source tool for capturing and replaying live HTTP traffic into a test environment in order to continuously test your system with real data. It can be used to increase confidence in code deployments, configuration changes and infrastructure changes. https://goreplay.org

HTTP Prompt is an interactive command-line HTTP client featuring autocomplete and syntax highlighting.

Dalsukh Tapaniya:

You can set a mood with colors, draw attention, or make a statement. To energize or cool down, you can use color. You can create an atmosphere of elegance, warmth or tranquility by choosing the right color scheme, or you can convey an image of playful youthfulness.

This photo is my failed attempt to capture water splash using high shutter speed. Taking a splash water photography always requires a lot of trial and error as you need to sync your shutter click with the exact moment of the splash. The great thing about the digital camera is that you can take thousands of photos at the location and later review and delete all of them except your star photo.

Pixlr X is an excellent tool when you don’t want to download and install software on your machine and want full-featured photo editor to make few tweaks to your photos. You also don’t need to register or login to use Pixlr X to work on the editor. Give it a try!

In the world of monitors, there are two kinds of people. Those who prefer ultrawide monitors and those who prefer to use a dual monitor set up.

There is no dispute; dual monitors are best for productivity.

Hillel Wayne:

This article is about some of the little tricks that I use in Vim. None of them are deep dives, and I encourage you to learn more about whatever’s interesting.

This little AutoHotKey snippet will make copying rich text and pasting as clean text a bit less hassle:

1
2
3
4
5

^+v::
  clipboard := ClipboardAll ;Copy clipboard contents to a variable
  Clipboard = %clipboard% ;Save content of the variable back to the clipboard
  Send ^v ;Send Ctrl+V command
  return

The assigned shortcut key is Ctrl+Shift+V, which you can change per your preference. Copy any rich text from a web site, open word document or new email in Outlook and press Ctrl+Shift+V. AutoHotKey snippet will remove all style formattings and will paste just the clean text.

Is there any impact in execution performance because of using array.Length directly as for exit condition? Which one of following methods will excute faster?

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

public int WithoutVariable() {
    int sum = 0;
    for (int i = 0; i < array.Length; i++) {
        sum += array[i];
    }
    return sum;
}

public int WithVariable() {
    int sum = 0;
    int length = array.Length;
    for (int i = 0; i < length; i++) {
        sum += array[i];
    }
    return sum;
}

Dmitry Yudakov concludes through digging into the IL code generated by JIT compiler for both methods:

… both methods will compile into the exact same code, but the first one is written faster, even though there isn’t any benefit in terms of execution time.

Bình Nguyễn:

An organized reading list for illustrating the patterns behind scalable, reliable, and performant large-scale systems. Concepts are explained in the articles of prominent engineers and credible references. Case studies are taken from battle-tested systems that serve millions to billions of users.

An excellent article by Nico Riedmann on the concept behind GIT. Do check out his GIT repository git_training as well, which has an interactive git training on how GIT works.

Andrew Lock on some of the quirks of using JObject, in particular the way it doesn’t honour the contract resolver settings used to serialize a given object graph, and three different ways to work around the behavior: set the global serializations settings, store the JObject using camelCase property names, or convert from a PascalCase JObject to a camelCase JObject. For the final option, a provided an extension method and unit tests to demonstrate the behavior.

Caleb Winston:

Heaps are a simple data structure that are really good at storing data where the only thing you care about is the element with highest priority.

In this email exchange, Alan Kay, the person who invented the term Object-Oriented, outlined the original intent behind the term Object:

OOP to me means only messaging, local retention and protection and hiding of state-process, and extreme late-binding of all things. It can be done in Smalltalk and in LISP. There are possibly other systems in which this is possible, but I’m not aware of them.

Interested in learning Git? Learn Git Branching is the most visual and interactive way to learn Git on the web; you’ll be challenged with exciting levels, given step-by-step demonstrations of powerful features, and maybe even have a bit of fun along the way.

Keeping exposure timing less than a half second has another benefit other than tack sharp leaves and branches. If someone inadvertently walks into your long exposure waterfall framing, you take that opportunity and include that person into your photo with less probability of that person will blur out.

I was so happy to take this shot. The person in the photo counterbalances the waterfall in the overall structure of the composition. This balance shifts the attention away from the waterfall as the main subject adds another dimension to the composition, which will be otherwise a predictable and bland photo.

This article implements the Implicit Grant OAuth flow and utilize these identity and authorization protocols by implementing IdentityServer4 as our OpenID Connect Provider and then using it to authenticate our Angular SPA client to authorize access to an independent ASP.NET Core Web API.

By Janne Aukia

Uibot is an experiment on how far one could automate the generation of visual designs, what kinds of advantages it would lead to and what issues one would face.

This online tool generates a basic CSS Grid code to make dynamic layouts.

Provide your grid configuration and hit Please may I have some code button and voila! You will have your CSS style ready to be copied.

.parent {
  display: grid;

  grid-template-columns: 50px 1fr 3fr 1fr 50px;

  grid-template-rows: 75px 1fr 75px;

  grid-column-gap: 0px;

  grid-row-gap: 0px;

  .div1 { grid-area: 1 / 1 / 2 / 6; }
  .div2 { grid-area: 2 / 1 / 3 / 2; }
  .div3 { grid-area: 2 / 2 / 3 / 3; }
  .div4 { grid-area: 2 / 3 / 3 / 4; }
  .div5 { grid-area: 3 / 2 / 4 / 5; }
  .div6 { grid-area: 3 / 5 / 4 / 6; }
}

Get off Medium and onto the JAMstack. Migrate from a proprietary service to an open stack - own your content and control how its displayed, shared & monetized.

“What one programmer can do in one month, two programmers can do in two months.”

— Fred Brooks

Milos Protic:

… the clean code can be defined as the code written in such a manner that is self-explanatory, easy to understand by humans and easy to change or extend.