March 26, 2024
To sort the data array, we can use many methods. Incorrect selection can lead to errors that are difficult to detect with uniform, standard-format test data. I would like to share some errors and solutions that I have encountered in a React project, as follows:
March 22, 2024
Your company is using Google Workplace, You have many information in Gmail, Google Drive, Google Calendar, Google Contacts and others alike. Suddenly, you remember you need to find some information, and you don't remember where that information is in Google Workplace. Google Cloud Search is is what you need in this case.
March 22, 2024
Cookie-base is one of the primary uses for session management. It is easy to implement, suits smaller applications, and has a lower server load but may offer less security than others.
As cookies are susceptible to client-side security risks, the key to safeguarding user information from unauthorized access is to carefully encrypt the sensitive data before storing it in the cookie. This way, even if a cookie is stolen, the data inside remains unreadable.
March 20, 2024
In today's digital world, data security has become a top priority for businesses and organizations.
Microsoft Azure, one of the world's leading cloud computing platforms, has introduced a powerful solution to this problem, which is a KeyVault.
March 19, 2024
In today's digital age, real-time communication has become a crucial aspect of web applications. Whether it's for live chats, collaborative editing, or dynamic data updates, users expect instantaneous responses. Achieving this functionality is made possible by technologies like Socket.io, particularly when combined with the power of Node.js on the backend and React.js on the frontend.
February 27, 2024
In the dynamic world of technology, programmers encounter a diverse array of challenges. These range from debugging intricate code to devising innovative solutions for software development projects. Amidst this complexity, ChatGPT emerges as a valuable companion for programmers, offering several advantages to streamline and enhance their coding experience.
January 11, 2024
The software production and business environment is becoming more and more competitive, customers have more and better choices of high-quality products or services on the market.
Companies must differentiate themselves from the competition by hearing customer requirements and providing products or services that meet customer requirements with high levels of reliability and quality.
The cost of quality is all of the costs that the software development team must bear to ensure the production of quality products or services.
The cost of quality allows the software development team to analyze the causes of problems and improve their products or services.
The cost of quality associated with a project consists of the cost of good quality and the cost of poor quality.
The cost of good quality (Cost of conformance) includes Prevention costs and Appraisal costs.
The cost of poor quality (Cost of nonconformance) includes Internal failure costs and External failure costs.
These are costs associated with preventing problems and errors from occurring during the development of a product or service.
This includes activities such as training, process improvement, quality management planning, etc.
These are costs associated with evaluating product or service quality by finding errors and detecting defects during the development of a product or service.
This includes activities such as testing, inspection, etc.
Internal failure costs are the costs that arise when problems or issues are found and corrected before the product or service is released to users.
This includes costs associated with rework, scrap, etc.
External failure costs are the costs that arise when problems or bugs are found in a product or service after it has been released to users.
This includes costs associated with customer complaints, warranty claims, etc.
In summary, the cost of quality plays an important role in ensuring the quality of a product or service and creating value for customers.
The software development team should invest in preventing problems and errors from occurring by training employees on quality,
improving quality control processes and strengthening evaluation activities of product quality in the production process to ensure that the product or service meets quality standards and customer requirements.
The optimal cost of quality reflects the appropriate balance for investing in the cost of prevention and appraisal to avoid failure costs (internal/external).
Image Source
https://www.freepik.com
December 8, 2023
By creating a tunnel from your computer (desktop, localhost) through the Firewall/Nat system, you can access the workstation from the internet. Ngrok can help you run project demos for customers to view from their own computers without needing to deploy the web to the server.
Additionally, you can test responsiveness on mobile easily through the URL that Ngrok provides and build a webhook to your local host.
Ngrok is available for macOS, Windows, and Linux.
When you use Ngrok, you start it on your local machine and specify the port number of the local server that you want to expose. When you do that, Ngrok creates a secure tunnel to a public endpoint (a ngrok.io URL) that is accessible over the internet.
So now, all the traffic to the public endpoint is forwarded as a request to the local server running on your machine. Your local server responds to this request or traffic back to this public endpoint. This is also called port forwarding or localhost tunneling. This is the underlying principle through which Ngrok maps your local development server to one of its servers, making it seem like it’s just your local development server hosted somewhere.
Ngrok currently includes 1 free package and 3 paid packages.
About pricing: https://ngrok.com/pricing
Ngrok is a highly secure platform for remote access and is safe to use. Ngrok provides tunneling, as mentioned above, which enables users to access local-hosted servers from outside the machine.
https://ngrok.com/download
You need to go to the homepage https://dashboard.ngrok.com/, register and manage your account, here after logging in, go to the Your Authtoken section to get the login token.
Run the following command in your terminal to install the auth token and connect the Ngrok agent to your account.
-> ngrok config add-authtoken <TOKEN>
Step 3: Start Ngrok by running the following command
-> ngrok http http://localhost:8080
If your app is listening on a different URL, change the above command to match.
As shown above, the tunnel is created - press CTRL+C to terminate this connection, once the connection is maintained you can access your web application using the URL provided by ngrok
You can access this address from any device on the internet such as using your phone to access, send to friends, send customers to check first...
We’ve learned how Ngrok works internally by understanding the concept of port-forwarding and local-host tunneling. Ngrok is an extremely helpful tool for developers, especially for testing and debugging purposes in various types of applications.
[1]: https://ngrok.com/
[2]: https://www.huntress.com/hubfs/Blog%20-%20The%20State%20of%20the%20Dark%20Web/Blog-Ngrok-Tunnelling.jpg
[3]: https://requestly.io/wp-content/uploads/2023/09/646e1ca5cf42db6cf447b6cd_5.webp
December 7, 2023
== operator can be overridden. So, no guarantee that the results will be as we expectvar lstEmployee = GetEmployees();
if (lstEmployee == null)
{
// ...
}
Good: Using is operator instead
var lstEmployee = GetEmployees();
if (lstEmployee is null)
{
// ...
}
IDisposable interface to release unmanaged resourcespublic class Stock{ private Stream _ioStream; public Stock(string filePath) { _ioStream = File.OpenRead(filePath); }}public class Stock: IDisposable{ private Stream _ioStream; public Stock(string filePath) { _ioStream = File.OpenRead(filePath); } // Disposing the unmanaged resource. public void Dispose() { _ioStream?.Dispose(); }}ConfigureAwait(false) to prevent deadlockspublic async Task<string> LoadData(){ var data = await ReadData(); return ProcessData(data);}public async Task<string> LoadData(){ // Use ConfigureAwait(false) to avoid potential deadlocks var data = await ReadData().ConfigureAwait(false); return ProcessData(data);}Parallel loops to take advantage of multicore CPUsNot good: a standard for loop is used to process the data collection, it will execute of sequential operations
private void ProcessData(List<int> data)
{
for (int i = 0; i < data.Count; i++)
{
TakeOperation(data[i]);
}
}
Good: Using Parallel loops can speed up processing of large collections, helping to optimize processing times
private void ProcessData(List<int> data)
{
Parallel.ForEach(data, item => TakeOperation(item));
}
ToList() or ToArray() when needed to improve performance
Not good: IEnumerable will be enumerated multiple times when processing.
public IEnumerable<int> GetOddNumbers(IEnumerable<int> numbers)
{
var odds = numbers.Where(n => n % 2 != 0);
return odds;
}
Good:
public IReadOnlyList<int> GetOddNumbers(IEnumerable<int> numbers)
{
var odds = numbers.Where(n => n % 2 != 0);
return odds;
}
Not good: a new string object is created when each element of "stringArray" is appended to "result", wasting processing time and memory
private string ProcessString(string[] stringArray)
{
string result = "";
for (int i = 0; i < stringArray.Count; i++) {
result += stringArray[i];
}
return result;
}
Good: use only one StringBuilder, save processing time and memory
private string ProcessString(string[] stringArray)
{
StringBuilder stringBuilder = new StringBuilder();
for (int i = 0; i < stringArray.Count; i++){
stringBuilder.Append(stringArray[i]);
}
return stringBuilder.ToString();
}
Span over arrays to circumvent unnecessary memory allocations and copyingbyte[] inputData = GetData();ProcessingData(inputData);
byte[] inputData = GetData();
Span<byte> spanData = inputData.AsSpan();
ProcessingData(dataSpan);
Lazy Loading for Resourcesvar employeeImage = LoadImage();// Some processsingLazy<Bitmap> employeeImage = new Lazy<Bitmap>(() => LoadImage());// After doing some processsing
//... // Load the image when accessedBitmap actualEmployeeImage = employeeImage.Value;
These are just a few examples for improving performance when working with C#.
I hope you find this article is helpful.
https://www.c-sharpcorner.com/UploadFile/dacca2/5-tips-to-improve-performance-of-C-Sharp-code/
https://dev.to/bytehide/7-simple-optimization-tips-in-c-nhn
https://code-maze.com/csharp-tips-improve-quality-performance/
https://www.bytehide.com/blog/performance-optimization-tips-csharp
Image source: https://www.freepik.com/free-vector/stream-binary-code-design_16399103.htm
December 7, 2023
In the mid-1990s, Robert C. Martin gathered five principles for object-oriented class design, presenting them as the best guidelines for building a maintainable object-oriented system.
Michael Feathers attached the acronym SOLID to these principles in the early 2000s.
Single Responsibility Principle (SRP).
Open-closed principle (OCP)
Liskov Substitution Principle (LSP)
Interface Segregation Principle (ISP)
Dependency Inversion Principle (DIP)
The “S” in SOLID is for the Single Responsibility Principle. Classes should have one, and only one, reason to change. Keep your classes small and single-purpose.
Ex: Class ProductManager is performing 3 tasks: getting data from the database, processing data, and printing reports.
class ProductManager {
public void QueryDataFromDB();
public void ProcessData();
public void PrintReport();
}
The ProductManager class is performing 3 tasks: getting data from the database, processing data, and printing reports. One class performs many tasks, so it violates the Single Responsibility Principle.
According to the principle, we need to separate this class into 3 separate classes so that the code is easy to read, has few bugs, and is easy to maintain.
class ProductManager {
public void QueryDataFromDB();
}
class ReportLogic {
public void ProcessData();
}
class PrintService {
public void PrintReport();
}
The “O” in SOLID is for the Open-Closed Principle. Design classes to be open for extension but closed for modification; you should be able to extend a class without modifying it. Minimize the need to make changes to existing classes
Ex: We have a ConnectionManager class that can be implemented to connect to database systems such as SQL Server, and MySQL.
class ConnectionManager {
public function doConnection(object $connection) {
if ($connection instanceof SqlServer) {
// connect with SqlServer
} elseif ($connection instanceof MySql) {
// connect with MySql
}
}
}
With the above class, if we want to support another database system like PostgreSQL, we must modify the class to support creating a connection to PostgreSQL, thus violating the Open-Closed Principle.
To not violate the above principle, we can correct it as follows:
abstract class Connection {
public abstract function doConnect();
}
class SqlServer extends Connection {
public function doConnect() {
// connect to SqlServer
}
}
class MySql extends Connection {
public function doConnect() {
// connect to MySql
}
}
class ConnectionManager {
public function doConnect(Connection $connection) {
$connection->doConnect();
// do something...
}
}
The “L” in SOLID is for the Liskov Substitution Principle. Subtypes should be substitutable for their base types. From a client's perspective, override methods should not break functionality.
Ex: We define the Brid interface to have 3 functions: fly(), eat() and walk ().
interface Bird {
public function fly();
public function walk();
public function eat();
}
class Pigeon implements Bird {
public function fly() {
// do something
}
public function walk() {
// do something
}
public function eat() {
// do something
}
}
class Penguin implements Bird {
public function fly() {
// penguin can not fly.
}
public function eat() {
// do something
}
public function walk() {
// do something
}
}
In the case of the Pigeon class implementing Bird, it is correct, but the Penguin class implementing Bird violates the Liskov Substitution Principle because Penguin cannot fly.
We can fix it in the following way so as not to violate the Liskov Substitution Principle.
interface Bird {
public function eat();
}
interface FlyingBird extends Bird {
public function fly();
}
interface WalkingBird extends Bird {
public function walk();
}
class Pigeon implements FlyingBird, WalkingBird {
public function fly() {
// do something
}
public function eat() {
// do something
}
public function walk() {
// do something
}
}
class Penguin implements WalkingBird {
public function eat() {
// do something
}
public function walk() {
// do something
}
}
The “I” in SOLID is for the Interface Segregation Principle. Clients should not be forced to depend on methods they don’t use. Split a larger interface into several smaller interfaces.
Ex: The Bird interface defines many functions, but not every class that inherits this interface uses all the functions that have been defined. For example, Pigeon implementing Bird cannot use the fly function.
interface Bird {
public function fly();
public function walk();
public function eat();
}
We can divide the Bird interface according to each function as follows:
interface Bird {
public function eat();
}
interface FlyingBird extends Bird {
public function fly();
}
interface WalkingBird extends Bird {
public function walk();
}
Dependency Inversion Principle (DIP)
The “D” in SOLID is for the Dependency Inversion Principle. High-level modules should not depend on low-level modules; both should depend on abstractions. Abstractions should not depend on details; details should depend on abstractions.
Why does SOLID help programming be more efficient?
Easy to understand: The clear division of functions of each class makes reading the code easier to understand.
Easy to update & maintain: Because it is easy to understand, updating or maintaining will be easier when a bug occurs.
Reuse: because the components do not depend on each other, each module can be separated and these modules can be reused for future projects.
[Reference Source]