teleren/devto huggingface dataset:
Critical Thinking in Software Design
Published: 2022-09-07 13:42:15

---
title: Critical Thinking in Software Design
published: true
description: Four methods for thinking about how you design software
tags: 
canonical_url: https://davidtruxall.com/critical-thinking-in-software-design/
---

Inc published [a great article a while back](http://www.inc.com/paul-schoemaker/4-secrets-of-great-critical-thinkers.html) which enumerates four secrets of great critical thinkers. I find the concepts in this article are totally relevant to designing software or software architecture even though that's not what the article is about. So I’m adding my programmer's take on these four secrets:

##Slow Down

One of my main gripes about meetings is making a decision on the spot. At least for me, my best thinking occurs somewhere else after the fact. I need time to consider the implications and possibly see alternatives before I can be certain it’s the correct decision. So to make the most effective decisions, postpone immediate decisions as often as possible. Make the time to explore the alternatives.

##Break from the Pack

This is the basis of one of the main arguments by [Ted Neward](https://twitter.com/tedneward) in his keynote at Codemash 2012 that [I already covered](http://blog.davidtruxall.com/2012/01/15/codemash-nuggets/). The “best practices” are found in books, on the web, in corporate documents. Generally, these can get the job done. But I doubt it’s always the best or right solution to a problem. It’s certainly the safest. If that’s the goal, then go that way. But in business we are always looking for an advantage, and I doubt the best practice gives you the advantage. More likely, it’s a starting point which you should use to find the best solution. Slow down and think about how the best practice solves the problem and if that is really the solution you need.

##Encourage Disagreement

I have long used this as a metric in [my interview process](https://davidtruxall.com/technical-resumes-and-interviews/). I want team members who will express their opinions. Usually the best answer to a problem is not the idea of a single person, but an amalgamation of ideas or compromise between multiple ideas. If no one can disagree with the boss/tech lead/manager then you might as well adopt only the best practices and call it done.

##Engage with Maverics

I think this one is a little harder in an enterprise environment, since often a big corporation is not the home for maverics. I think what you need to do here is actively engage with people whose viewpoints are not aligned with yours. People who think differently about a problem may provide you with some insight you may have missed or not considered properly. I have always thought of code reviews as a source for this. I approach code reviews as a way to see someone else’s problem solving at work. I’m not interested in telling them how they did it wrong, but seeing what they did well and adapt that to my problem solving toolkit.

I try to revisit these topics and remind myself to practice these concepts as I do my work, it's too easy to get lost in the moment writing code. I hope you can do the same.
Traefik middleware - Basic authentication
Tags: kubernetes, javascript, node, devops
Published: 2022-09-07 13:38:50

In this article we will explain how to use Traefik middlewares and routers to manage authentication to many applications on Kubernetes.

- [Traefik authentication middleware](#traefik-authentication-middleware)

  - [Basic Authentication](#basic-authentication)

    - [Deploy the authentication middleware](#deploy-the-authentication-middleware)

  - [Go further](#go-further)



## Basic Authentication

Basic auth is a good way to restrict access to users you choose. 

To manage **Basic Authentication** with Traefik, we will use the [BasicAuth Middleware](https://doc.traefik.io/traefik/middlewares/http/basicauth/#basicauth).

First, you need to define a secret with the Basic Authentication users at the format `name:hashed-password` with password hashed using **MD5**, **SHA1**, or **BCrypt**.

You can hash passwords using the following command: 'htpasswd -nb user password'.

```yaml
apiVersion: v1
kind: Secret
metadata:
  name: basic-auth-users-secret
stringData:
  users: |>
    user1:$apr1$rKM7TQZQ$FUFmIklAwWBy80pHFcZlM0
    user2:$apr1$elAEjLXh$l5NtPMsZ5YmZhjKPJ5u4r/
```

and the middleware instance:

```yaml
apiVersion: traefik.containo.us/v1alpha1
kind: Middleware
metadata:
  name: test-basic-auth
spec:
  basicAuth:
    secret: basic-auth-users-secret
```



You can now use the middleware in Traefik routers:

```yaml
apiVersion: traefik.containo.us/v1alpha1
kind: IngressRoute
metadata:
  name: test-basic-auth
spec:
  entryPoints:
    - web
  routes:
    - kind: Rule
      match: Host(`test-basic-auth.lenra.io`)
      middlewares:
        - name: test-basic-auth
      services:
        - kind: Service
          name: my-service
          port: 8080
```



Stay tuned, we will see soon how to set up the forward authentication middleware !
Introduction to Windows Cloud Desktop
Published: 2022-09-07 13:17:42

Windows Cloud Desktop is a technology related to deploying and managing virtual desktops using virtual machines. Windows Cloud Desktop hosts desktop environments on the main server and makes them available to end users on demand.

**How does Windows Cloud Desktop work?**
With Windows Cloud Desktop, the hypervisor divides the server into [Azure Virtual Desktop](https://www.clouddesktoponline.com/what-is-windows-virtual-desktop-wvd/) which hosts the virtual desktops that users access remotely from their devices. Users can access these virtual desktops from a variety of devices and locations, and all processing takes place on the host server. A user is associated with a desktop instance through a connection broker. 
Windows Cloud Desktop is persistent or non-persistent. Each type has different advantages. Persistent [Windows Cloud Desktop](https://www.clouddesktoponline.com/) saves modifications even after a connection reset, permitting users to connect to the same desktop every time and personalize their desktops as needed. In other words, desktops in persistent VDI environments behave like personal physical desktops.
In contrast, non-persistent VDI, where users connect to generic desktops and changes are not saved, is typically simpler and cheaper because there are no custom desktops persisted between sessions. Non-persistent VDI is mainly used in organizations that have many tasks or employees performing limited repetitive tasks and do not need customized desktops.
**Conclusion**
Hosted virtual desktops don't take up a lot of space in your office. This feature is a good option for many small businesses with compact office spaces. Its hosting provider, Apps4rent, not only helps you set up virtual desktops, but it also maximizes the availability of virtually hosted desktops.
Présentation :
Tags: news, career
Published: 2022-09-07 13:31:32

## Salut à tous ! Je m'appelle Thomas, je suis développeur web front-end, actuellement en formation fullstack.
Sur ce blog, je vais vous parler de plusieurs sujets : 
* **Cours HTML/CSS**
* **Tips HTML/CSS**
* **Comment faire un site x**
* **D'autres cours/formation**.                                            

Je pense que ce site est un bon début pour mon projet de cours / formation. J'espère que vous apprécierez.
A très bientôt !
looking for privy front-end projects that could be developed into full stack projects
Tags: webdev, javascript, react, beginners
Published: 2022-09-07 13:28:07

Hey guys , I wanted to start on a unique front-end project that could be later on made a full stack project.I am getting confused and not being able to think much. Have to submit project idea by day after tomorrow. Can you guys help. I have to showcase front-end part of the project in 2-2.5 months.
How to monitor DataBricks with Amazon CloudWatch
Published: 2022-09-07 13:11:19

Importance of Monitoring Systems

Software engineers often forget the importance of monitoring systems that run their infrastructure. When things go wrong, they do not have the tools to detect and react to issues fast enough. This can be dangerous because it may take them hours or even days to notice and correct the problem. And during those hours or days, the service may be unavailable. So they can lose a lot of business. You can read more on how to monitor applications with AWS effectively.




DataBricks Lakehouse

The Databricks Lakehouse platform offers users a way to manage their data in one place - on-premises or on the cloud - while enabling organizations to use AI, ML, and IoT solutions from the same platform.

You don't need to build a new architecture or software when you have data in the lake. You get full access to the data - whether it resides in the cloud or on-premise. Your users can easily access and share data using the tools and APIs they already know. And the platform is designed so that users can evolve quickly, with minimal effort and time commitment, while avoiding the risk of investing time and money in building a separate data warehouse.










AWS CloudWatch




An AWS account allows you to use the resources of the cloud, including the elasticity, security, availability, and scalability of your applications. Amazon CloudWatch is a part of the AWS family that assists in monitoring, alerting, and collecting analytics for our AWS environments.

The solution offered by Amazon will help you keep track of everything you use on the cloud. This includes both resources and services. It will tell you whether those resources and services are currently working and if any issues need to be addressed. Also, you can check the troubleshooting practices regarding CloudWatch.

Although this isn’t a novel idea, AWS with Amazon CloudWatch will provide benefits to you. So let’s look at steps for integrating Databricks with AWS CloudWatch, which will further top you run your data applications more efficiently. You can check the [](url)detailed tutorials about billing, concepts, and the services given by aws cloudwatch here.


How DataBricks Integrate with CloudWatch
To read the steps visit [here](https://sudoconsultants.com/how-to-monitor-databricks-with-amazon-cloudwatch/)


Conclusion :

With the integration of DataBricks with AWS Monitoring service CloudWatch you can locate the problems before they impact your entire organization, if you use monitoring and alerting. These tools allow you to spot slow jobs or jobs that haven't completed successfully, so that you can fix any issues that are causing these delays before they affect your data pipelines. Monitoring can also help you identify larger data sets or detect regional outages, so you can take action and prevent data loss.
How Programming and Classic Television are Alike
Tags: jokes, watercooler, programming, discuss
Published: 2022-09-07 13:10:33

What does programming have to do with Mr T, Cheers, the Golden Girls, the Brady Bunch, Full House, Quantum Leap, Gilligan's Island, Oscar the Grouch, Family Matters, Home Improvement, and Night Court? Probably nothing. But none-the-less this post connects programming to classic American television shows, personalities, and characters.

Did I miss any?

__Table of Contents:__
* [Classic TV meets the classic `foo` and `bar`](#classic-tv-meets-the-classic-raw-foo-endraw-and-raw-bar-endraw-) 
* [C, Lisp, Fortran, and Smalltalk](#c-lisp-fortran-and-smalltalk)
* [A fork join thread pool](#a-fork-join-thread-pool)
* [Buffer overflow](#buffer-overflow)
* [2D array](#2d-array)
* [Rewriting git history](#rewriting-git-history)
* [Memory leak](#memory-leak)
* [Garbage Collector](#garbage-collector)
* [Debugging](#debugging)
* [Refactoring](#refactoring)
* [Code reviews](#code-reviews)
* [Where you can find me](#where-you-can-find-me)

## Classic TV meets the classic `foo` and `bar`

> Mr T (as a programming instructor): I pity the `foo`

(Mr T is certainly a classic TV icon even if this one is based on a movie quote.)

And a code example:

```Python
def foo(person) :
    return "Mr T pities {0}, a fool.".format(person)
```

{% wikipedia https://en.wikipedia.org/wiki/Mr._T %}


And of course you can't use the classic function name `foo` in an example without also having an example with variable `bar`:

```Python
bar = "Cheers"
```

{% wikipedia https://en.wikipedia.org/wiki/Cheers %}


## C, Lisp, Fortran, and Smalltalk

{% wikipedia https://en.wikipedia.org/wiki/The_Golden_Girls %}


## A fork join thread pool

{% wikipedia https://en.wikipedia.org/wiki/The_Brady_Bunch %}


## Buffer overflow

{% wikipedia https://en.wikipedia.org/wiki/Full_House %}


## 2D array

Here's The Brady Bunch again, or more specifically their opening credits title image....

![The Brady Bunch title image](https://upload.wikimedia.org/wikipedia/en/8/8a/BradyBunchtitle.png)

Image from: https://upload.wikimedia.org/wikipedia/en/8/8a/BradyBunchtitle.png


## Rewriting git history

{% wikipedia https://en.wikipedia.org/wiki/Quantum_Leap %}


## Memory leak

{% wikipedia https://en.wikipedia.org/wiki/Gilligan%27s_Island %}


## Garbage Collector

{% wikipedia https://en.wikipedia.org/wiki/Oscar_the_Grouch %}


## Debugging

> Steve Urkel: Did I do that?

{% wikipedia https://en.wikipedia.org/wiki/Family_Matters %}


## Refactoring

{% wikipedia https://en.wikipedia.org/wiki/Home_Improvement_(TV_series) %}


## Code reviews

{% wikipedia https://en.wikipedia.org/wiki/Night_Court %}


## Where you can find me

Follow me here on DEV:

{% user cicirello %}

Follow me on GitHub:

{% github cicirello/cicirello %}
Key concepts in software architecture
Tags: software, architecture, programming, productivity
Published: 2022-09-07 12:56:33

When talking about software architecture, there are a few key concepts that come up over and over. These concepts include modularity, abstraction, layering, and separation of concerns. Let's take a look at each of these concepts in turn.

Modularity is the idea of breaking a large system into smaller pieces that can be independently developed, tested, and deployed. A good example of modularity is the way that most web applications are built using a front-end (what the user sees and interacts with) and a back-end (where all the data is stored and processed). This separation allows different teams to work on different parts of the application without having to worry about stepping on each other's toes.

Abstraction is the process of hiding complexity from the user. A good example of abstraction is an API (Application Programming Interface). An API exposes only the functionality that a developer needs to use, while hiding all of the underlying implementation details. This makes it much easier for developers to use someone else's code without having to understand everything about how it works.

Layering is another way of dealing with complexity. When you layer your software, you break it down into different levels, with each level providing services to the level above it. For example, in a web application you might have a presentation layer (the part that generates HTML), a business logic layer (the part that contains all your application logic), and a data access layer (the part that talks to your database). By breaking things down into layers like this, you make it easier to develop, test, and deploy your software.

Separation of concerns is another important concept in software architecture. It simply means keeping different parts of your code independent from each other so that changes in one area don't affect other areas. For example, if you're building an e-commerce website then you might want to keep your shopping cart code separate from your payment processing code so that changing how one works doesn't break the other.

These are just a few of the key concepts that come up when talking about software architecture. By understanding and applying these concepts, you can build better, more maintainable software.
How to Build a Command-Line Text Editor With Java (Part 1)
Tags: java, tutorial, programming
Published: 2022-09-07 12:45:08

Have you ever wanted to know how text editors work? How shell scripts change terminal text colors, update lines without scrolling, or move the cursor around?

Surprise, surprise, even as Java Devs, we can do this! [In this series](https://youtu.be/kT4JYQi9w4w), l'll walk you through building a terminal-based text editor with Java.

Part 1: How to use ANSI escape codes and native C text input libraries to do fancy text output with Java. Let’s get started!

{% embed https://youtu.be/kT4JYQi9w4w %}
Clean your home folder ! discover XDG
Tags: linux, dotfiles, devjournal, tooling
Published: 2022-09-07 12:44:03

Today, I would like to talk about [XDG base directory specification](https://wiki.archlinux.org/title/XDG_Base_Directory)

You can read the article, but the idea is a guidance for people creating and maintaining software programs. 

## What is all about ?

You should have noticed there are a lot of files starting with `.` in your home directory. Some are configuration files, some are cache, some are runtime data.

## What is the problem ?

Well, it's a mess. Having all these files in your home folder is a bit strange, also not easy to follow if you have a dotfiles strategy.

![Before/After effect](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/435p68zoa0doj1kriwyp.png)


Instead of having

```
~/.gitconfig
~/.tmux.conf
...
...
```

you could have

```
~/.config/git/config
~/.config/tmux/tmux.conf
...
```

This specification is progressively adopted, you will see a lot of files in ~/.config/ or ~/.cache folders. These two are the most commonly used by the programs.

So right now, a lot of programs started to support XDG base directory specifications, some made the choice to use directly the ~/.config to store config files, some simply argues they don't want to support them 🤦.

You can imagine [the amount of mess](https://wiki.archlinux.org/title/XDG_Base_Directory#Supported)

## What are the benefits of using XDG

- it's cleaner
- you have one folder per program
- you can add a README.md file in each folder to take notes or to share information when sharing dotfiles on GitHub.

## How to start ?

You can do it manually, by reading every program man files... or ... you can use tools that will report you the things you can migrate.

Here are my favorites:

{% embed https://github.com/b3nj5m1n/xdg-ninja %}

The first one is only about reporting current status about each dotfile. It also reports a status for files that are currently unsupported, or when developers declined to support XDG. 

It provides you information on how to migrate them.

This one is very cool, because it will never simply make no change to your dotfiles.

{% embed https://github.com/doron-cohen/antidot %}

This one is about listing them, it reports a bit less results.
But it can help you to migrate them automatically.
Decision of New Series
Tags: discuss, challenge
Published: 2022-09-07 12:27:45

Hello Everyone, After a long time I am back on this platform again and this time I have decided to start a New Series `Tech Challenges Stories`.

**Why I am starting this series?**
On the daily basis I face new challenges while coding and that I solve using some tricks or _Jugaad_ . That's what I want to share and discuss with everyone. What kind of tricks I am using to solve those problems or their can be a better solution of that problem which we can get to know from each other. _I hope you all will help me in providing a better solution._

**What kind of problems I cover in this series?**
* Problems related to coding.
* Problems related to DevOps.
* Problems related to Leadership and Management
* Problems related to Architecture.
In initial phase we will start more from coding and DevOps. 

```If you want me to cover any other topics too then do let me know in comment box.```
Start Observing any smart contract!
Tags: web3, blockchain, monitoring
Published: 2022-09-07 12:01:13

Gm frens!

Today we are releasing our alpha version 🎉, and you are one of the first to know about it. Click on the button below and start observing any smart contract on Ethereum and Polygon.

We designed this version to help you do three things

- 🔭 Get the big picture of all your smart contracts at a glance
- 🏎 Browse through logs across chains and across contracts fast
- 🎯 Set Service Level Objectives to see anomalies


![blocktorch SLOs overview](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/8h127nao77ccci15xoth.png)


We are eager to hear your feedback! So try it at 🔥🔥🔥 https://app.blocktorch.xyz 🔥🔥🔥 or watch the demo video here 🎥

{% embed https://twitter.com/blocktorch/status/1567186703617507333?s=20&t=ovnHgCexJjyUl8grACRyLw %}

We are shipping more exciting features so stay tuned for exciting features planned to be shipped soon 🚢🚢🚢

WAGMI!
blocktorch team 🗽
Modals Accessible Components Release!
Tags: webdev, showdev, design, tailwindcss
Published: 2022-09-07 11:52:23

Hey everyone!

A wild new Accessible Component just appeared! 🎉

Tailwind Modals are now included in the list of components for wind-ui, with 5 diverse variations!

[https://wind-ui.com/components/modals/](https://wind-ui.com/components/modals/)
How to Pull from a Remote Repository
Tags: git, github, beginners
Published: 2022-09-07 11:49:49

Suppose you're working on a project with other developers. The first thing to do is to create a repository where all the workflow will take place. Since y'all are gonna contribute to the repo, you have to understand the git tools. Someone from the team has made some changes to the repo, how do you stay updated..? Instead of **zipping up files** and creating more confusion, all you need to do is **pull** their changes into your **local repository**. 

**How to pull the changes:**

1. Navigate to your Git repo folder in your chosen terminal.
2. Then run a **git pull** command.

So git pull is usually a combination of **git fetch** + **git merge**
It basically involves fetching **upstream changes** and syncing them with the **local ones**.


**When should I use git pull?**
1. Before you start working ~ to stay updated with the latest changes.
2. Before you push anything.

**Fetching the Changes:**
git fetch gets to download the latest remote repo changes.
git merge now merges those changes into your local codebase.

_And what if I want to review the changes first and not merge the code immediately..?_ ~ Just do a **git fetch** other than **git pull**.
You'll get to proceed as per the steps listed in the ~ **How to pull the changes**. The difference comes in the 2nd part, instead of running a **git pull** command, run **git fetch**.
New Accessible Alerts Component Released!
Tags: react, html, tailwindcss, news
Published: 2022-09-07 11:49:03

Happy new month with more free tailwind-only components added to the ever-growing wind-ui library 🎉 

Today we introduce alerts! 7 variations, unlimited colors and as always focused on user accessibility.

[https://wind-ui.com/components/alerts/](https://wind-ui.com/components/alerts/)
Accordion Accessible Components Release!
Tags: react, tailwindcss, css, news
Published: 2022-09-07 11:45:54

Back from holidays and back to releasing new tailwind components to our tailwind UI library!

Checkout the new native accessible accordion components with 6 variations! 

[https://wind-ui.com/components/accordions/
](https://wind-ui.com/components/accordions/
)

Feel free to share the ❤️
A tool to make developer's life easy when it comes to data base modelling
Tags: datascience, webdev, productivity, community
Published: 2022-09-07 11:44:22

DB Diagrams can have 40-50 data tables which can make the diagram messy and cluttered. In this cluttered view, it is hard to find tables based on a use case or a feature. 
What if, we had a tool that has the following capabilities?
-  Search tables easily in your DB diagram. 
- Create filters for your tables as per your feature or use-case to eliminate the distraction. 
- Collaboration