teleren/devto huggingface dataset:
Managed code
Tags: dotnet, programming, csharp
Published: 2023-01-09 23:57:51

Manage coded as I wrote before comes with a cost because the safety net that brings have multiple layers of complexity.

## Benefits
Managed code over unmanaged code indeed has a plus side.

### Type Safety
Enforced by the compiler and runtime, so objects are used as they are plus boundaries, overflow detection, here what's really important is that the heap can not be corrupted due invalid pointers or memory access violations.

Memory is managed, with some advanced language features found on a higher level of abstraction. Reflection certainly provides a dynamic component managing extensions.

## Drawbacks
- There is no access to the full processor instruction set.
- New windows features come first to C/C++ windows sdk and some functionality still don't have any managed wrapper.
- There is no direct memory access plus no control over the memory layout of structures.

## Performance
This high-level managed code is translated to Intermediate Language, then when the code is run the CLR invokes the JIT compiler to convert your IL to assembly code where most important code optimizations happen and also performance suffers this one time hit and from then you always get the compiled version.

The quality of the generated code is not on our hands which gets better on each .NET framework release. Memory management does have some points in favor with a properly configured garbage collector, since it compacts the heap memory fragmentation is less of an issue.

Another issue is that memory allocations are trivial and generic API features come with expensive implementations in favor of make them universal and here is the why and where we want to understand better the software we write as developers.
Zero Assumption’s Backbone of Rust
Tags: zeroassumptions, rust, zerotrust, networking
Published: 2023-01-10 00:57:38

Zero Assumptions is a zero trust networking solution you can use with your existing Identity Provider. All of your data is stored on-prem, so you control it all. 

While you won't have to write any foundational code to drive the functionality of Zero Assumptions for your organization, this article explores our usage of the [Rust](https://www.rust-lang.org/) language. The purpose being that you'll gain a stronger understanding of the mechanisms that drive Zero Assumptions, and why our product is secure, safe, and performant. 

We've built our solution on Rust for a number of reasons including its strong community support, packages on crates.io, and future-proofing. 

## Decrease Runtime Errors

Given that Zero Assumptions is on-prem first. Given the nature of our product, if the software goes down, then people can’t access their private resources. We have to send product that is as solid as possible at runtime. 

Rust is a memory-safe language that eliminates an entire class of errors without sacrificing performance. Specifically, in safe mode, Absence of Null prevents another class of bugs occurring in runtime.

## Consistent Quality and Longevity

Rust contributors intentionally keep the language backwards compatible. This means that when Rust changes, Zero Assumptions won't introduce breaking changes due specifically to using a newer version of Rust. 

When writing Rust itself, the language has no additional usage "cost" for abstractions. This will allow us to continue to iterate quickly without slowing down the end product.

It's also worth mentioning that Rust has robust and clear documentation, which greatly adds to the overall quality of the language. 

## Security 

When Rust compiles, it looks at memory compilation, which can prevent memory management problems. Rust also allows for more granular control over memory, so we can highly customize where we want to.

Zero Assumptions benefits from its Rust foundation on many levels. And while our users don't need to know any Rust, they'll reap all the rewards of Zero Assumptions being built on Rust. 

Follow Zero Assumptions here on [DEV](https://dev.to/zeroassumptions), [LinkedIn](https://www.linkedin.com/company/zero-assumptions/), and [Twitter](https://twitter.com/zeroassumptions) to stay up-to-date on our product. We're launching this year, 2023, and can't wait for you to use Zero Assumptions.
Tensorflow
Tags: internship, machinelearning, ai, outreachy
Published: 2023-01-10 00:48:46

## Introduction:

My experience at Mboalab organization during this internship period has been an amazing one. I have learnt alot regarding machine learning and some technologies. My favorite being Tensorflow, which after my research, I gathered the following regarding tensorflow terminology. 

## Body
Data is the most important factor in the success of machine learning projects. With TensorFlow, you can have multiple data tools to help you consolidate, clean and preprocess data at scale.

TensorFlow makes it easy for beginners and experts to create machine learning models for all platforms that is desktop, mobile, web, and cloud platforms.
Tensorflow can help you to:

- Prepare and load data for successful ML outcomes
- Load and preprocess an image dataset 
- Investigate and visualize datasets 
- Build and fine-tune models with the TensorFlow ecosystem
- Train a neural network to classify images 
- Serve a model with TensorFlow Serving 
- amongst others

## Conclusion
To get started, you can find tutorials on tensorflow here{% embed https://www.tensorflow.org/tutorials %}.
My simple text adventure game... with Aphids
Tags: beginners, python, computerscience
Published: 2023-01-09 22:08:18

Greetings,

I am a current computer science student and am also working through sites such as Codecademy, freecodecamp, etc. and had a project to create using Python. I chose a text adventure that that I used in one of my first courses and have refined it to meet the requirments for this project. I know it is fairly basic and that I could optimize the movement keys but I wanted to post what I had.


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ouejfokhzcujb2z0dsf3.png)

The image above shows the introduction with instructions and a map. Next, the prompts show how movement occurs between the rooms and how to get items. After an item is retrieved it shows on the screen in your inventory.

The code for the inventory highlights the use of python dictionary's and the inputted text parsed and split, then checked using if/elif statements.

Here is a link to my code if interested: [Aphid's Revenge](https://github.com/mroge-dev/CS101-Final-Project/blob/master/aphids_revenge.py)

I would love to hear any and all thoughts on things that are good and what needs improvement. 

Thanks!
Front-End is for me.
Tags: beginners, ruby, react
Published: 2023-01-10 00:41:36

 Three phases later, at Flatiron School, I finally grasped what my day-to-day life as a front-end or back-end developer. Completing Phase 3  was very interesting to me on how much goes into giving the websites we visit daily their substance. Back-end development is for individuals who enjoy the "making things work" side of developing. A few examples are troubleshooting and debugging applications, the website's performance, and focusing on the database. While creating our project, it was mind-blowing to realize what goes into my favorite sites like Youtube, Twitch, and Hulu. Back-end developers are the cause of why our experience is so user-friendly and flawless. 

```
Review.create(
      title: Faker::Lorem.sentence,
      rating: rand(1..10),
      hours: rand(10..200),
      review: Faker::Lorem.paragraph,
      game_id: game.id,
      gamer_id: gamer.id
    )
```
Above is an example of code from our project Game-a-holics. With this block of code, we used "Faker" to generate fake data  
to appear as if we have a lot of activity on our website. Faker came in handy for saving us time creating individual random reviews for each game. Now, what does a block of code that allows an actual user to post their own review look like? 

```
post '/reviews' do
    review = Review.create(
      title: params[:title],
      rating: params[:rating],
      hours: params[:hours],
      review: params[:review]
    )
    review.to_json
  end
```
Here this block of code allows the user to post their own review on an existing game on the site. When you get to see each step it takes to build the functions of the website. It makes you think how much code goes into finding your favorite episodes on your preferred streaming platform. 

Working through the process and seeing it come together led me to focus on front-end development. Front-end is definitely for individuals who love the creative side of web developing. For most junior developers one of the biggest frustrations in front-end is CSS. With my little experience in CSS, it is one of the most fun and incredibly frustrating things to learn in front-end. 

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/7s0i16i061pgmakccona.png)

I spent the entire day trying to give our search bars a little style. Personally, it was fun because it allowed me to strengthen my creativity with this new skill I'm learning. Learning back-end quickly made me realize that front-end keeps me more engaged and motivated when going through the process.
A BCryptDeriveKeyPBKDF2 example in C++.
Tags: cpp, c, bcrypt, crypto
Published: 2023-01-10 00:33:22

I had a heck of a time finding a simple example of this function. I eventually made my own...


```
#pragma comment(lib, "bcrypt.lib")
#include <Windows.h>
#include <string>
#include <iostream>

int main()
{
    std::string password = "This is the password that will be encrypted";
    std::string salt = "EncryptionSalt";
    NTSTATUS Status;
    BYTE DerivedKey[64];

    BCRYPT_ALG_HANDLE handle;
    Status = BCryptOpenAlgorithmProvider(&handle, BCRYPT_SHA512_ALGORITHM, NULL, BCRYPT_ALG_HANDLE_HMAC_FLAG);

    if (Status != 0)
    {
        std::cout << "BCryptOpenAlgorithmProvider exited with error message " << Status;
        goto END;
    }

    Status = BCryptDeriveKeyPBKDF2(handle, (BYTE*)password.data(), password.length(), (BYTE*)salt.data(), 8, 2048, DerivedKey, 64, 0);

    if (Status != 0)
    {
        std::cout << "BCryptDeriveKeyPBKDF2 exited with error message " << Status;
        goto END;
    }

    else
        std::cout << "Operation completed successfully. Your encrypted key is in variable DerivedKey.";

    BCryptCloseAlgorithmProvider(handle, 0);

END:;
}
```
Writing UI in .NET sucks
Tags: dotnet, programming, critique
Published: 2023-01-10 00:27:37

.NET is amazing. It allows me to write code for everything in one tooling, with minimal handholding, everything is (almost) self-contained, and most importantly, I can even code my own website using nothing but .NET if I wanted to...


...But I wouldn't wish anyone to code UI in .NET.


## The UI tooling is bad... very bad

Before you cranky bunch of people decide to pull out your recently polished mechanical keyboards and clack at the speed of sound stating about UI Frameworks like Avalonia, Uno Platform, MAUI, etc. Please hear me out:


.NET never really had a good cross-platform GUI solution that allowed us to work to our full potential. Most, if not all, UI tooling is Windows-specific (looking at you Blend), we don't have good WYSWYG editors, and it took as long as .NET 6 until it became competitive enough to be used as a framework for writing applications like Flutter.

## And we didn't have proper UIs for embedding them inside applications too!

Sure, we have the imgui framework and tons of other niche UI frameworks, but really, *that's all we have.* - and even then, they were cumbersome to integrate, usually taking more time to implement them in .NET than natively

Did I mention even the most popular CEF bindings are also Windows-only? This is sloppy on our part because we might have a fancy new framework, but we **never evolved beyond .NET Framework-isms.**

And to put the icing on this dysfunctional cake, Microsoft's own WebView2 library lacks some of the core facilities such as off-screen rendering, and still had some problems here and there by its own standards too, not a good look for a framework being championed by a company who is touting it as their own modern solution for writing things everywhere.

Oh, did I mention the only working embeddable UI right now I can find is also proprietary and requires a license?

## Our attitude with UI development needs to change

While I love the new innovations coming to .NET, most of them do not relate to what I need, and it feels like every second the community has neglected this side of development of .NET. This toolkit is more than just for ASP.NET, or for writing servers, or just for Windows-related stuff.


Where and what else does .NET's ecosystem or feature set do you find extremely lacking? Let's discuss in the comments.
Automatically send emails using Google SMTP with 3 easy steps
Tags: bash, linux, productivity, tooling
Published: 2023-01-10 00:10:16

If you need to automate tasks then you'll likely find this post useful. I like to be notified if an automated script fails or succeeds, depending on the situation.

You can get your scripts to email you using Google's SMTP server:

## 1. Set up a Gmail Password

Assuming you have a Google account and are signed in, visit <https://myaccount.google.com/apppasswords>.

Select "Other" from the **Select app** drop down:

![Google app password landing page](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/et83kay4c4ryxvftiq4f.png)

Give the app password a name. It can be whatever. Click "Generate" and you'll see something like this:

![Google app password generated](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/okdzkl22bpmqfubgdagm.png)

**Save this somewhere** else it shall be lost to the void.

When you click done your new app password will show up for you:

![Google app password saved](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/30jrvmkvsun8m1imh8lw.png)

## 2. Install mutt

If you're on Linux your distro will likely have the `mutt` package available in its repositories:

*Fedora/RHEL/CentOS*  
`sudo dnf install mutt`  
or  
`sudo yum install mutt`

*Ubuntu/Debian*  
`sudo apt install mutt`

*Arch/Manjaro*  
`sudo pacman -S mutt`

**Bonus:** mutt is also available on MacOS via Homebrew:  
`brew install mutt`

## 3. Configure mutt

Create a `.muttrc` file in your home directory.

`vi ~/.muttrc`

Fill it out with the configs, pasting in your app password from step 1 for the `smtp_pass` value:

```bash
set from = "<gmail-id>@gmail.com"
set realname = "<Your Name>"
set smtp_url = "smtp://<gmail-id>@smtp.gmail.com:587/"
set smtp_pass = "<smtp password generated in the google link above>"
```

In our case "smtp password generated in the google link above" is `vaykiyyakisiqmez`.

Now test it out -

`echo "This is an email body." | mutt -s "This is an email subject" recipient@example.com`

Tada! :tada:
The Product Delivery Paradox: the framework to help engineers simplify estimates and trade offs.
Published: 2023-01-10 21:35:29

---
title: The Product Delivery Paradox: the framework to help engineers simplify estimates and trade offs.
published: true
date: 2023-01-10 00:00:00 UTC
tags: 
canonical_url: https://eddiehinkle.com/articles/product-delivery-paradox-the-framework-to-help-engineers-simplify-estimates-and-trade-offs
---

 ![The Product-Delivery Paradox Diagram](https://eddiehinkle.com/_next/image?url=%2F_next%2Fstatic%2Fmedia%2Fproduct-delivery-paradox.2bac02c7.jpg&w=3840&q=75)

Product delivery is simple and complex, all at the same time. The issue is that we always want 3 dimensions of delivery. We want it:

- Quickly (Time dimension)
- Bug-free (Quality dimension)
- All the “important” features (Scope dimension)

The problem is that you can only deliver on 2 of the 3 at the same time.

## If you want a lot of features quickly, you have to sacrifice quality.

Because if you are trying to do a lot of things quickly, the only thing you can adjust is the build quality.

Do you write automated tests? Work through all the edge cases and scenarios? Odds are, when you are rushing (which you are if you’re trying to do a lot of features fast), you will miss things, and the end result will feel less refined or have strange bugs.

The problem with this approach is that many of the issues are hidden from the view of anyone who isn’t looking from the technical aspect. Because of that, this is the angle that Product Managers tend to lean into.

## If you want a lot of high-quality features, it will take a long-time.

Software Engineers love nerding out on tech.

Let’s make things reusable! What kind of crazy scenarios might happen? Does someone have 10 words in their name? Thinking through technical excellence and building a fully working piece of software is one of the best spots for an engineer to be in.

But the problem is, without modifications, the natural inclinations of most software engineers is how we got waterfall software development that goes over budget and over deadlines.

## The best approach is a small number of high-quality features that can be done quickly.

This is what agile was meant to be before it became a buzzword—it’s how you deliver and iterate on magical experiences.

It’s the most challenging part of software design and development, but it’s essential to make the software the best it can be.

Limit the number of features, think through edge cases, and write automated tests. But because you limit the number of features, you keep the scope small, and you can ship software quickly and reliably.

So the next time you’re pulled into a discussion on what will be built and when it’ll be ready, bring the product-delivery paradox triangle with you.
What is Software-as-a-Service or Public Cloud Application Software
Tags: saas
Published: 2023-01-11 06:32:29

---
title: What is Software-as-a-Service or Public Cloud Application Software
published: true
date: 2023-01-10 00:00:00 UTC
tags: SaaS,SaaS
canonical_url: https://plakhlani.in/saas/What-is-Software-as-a-Service/
---

> **Public Cloud Application Software or Software-as-a-Service (SaaS) is cloud-based, on-demand software offered to businesses or individuals that solve problems for them.**

For example, Salesforce provides CRM, Office 365 provides productivity tools, and Box provides File sharing are examples of SaaS software.

Many SaaS software offers **free subscriptions** based on limited usage, which is advantageous to startups, small business and entrepreneurs as they couldn’t have afforded such a useful software otherwise.

Cost-effective, flexible subscription, pay only for what you use and no waste of time are some of the many advantages why so many businesses use SaaS software that are popular in their industry.

SaaS software market is continuously growing every year. There are still many opportunities exists to solve such industry specific problems.

SaaS software are changing the way businesses operate by solving their critical problems and help them save lots of time and cost.

At [Facile Technolab](https://www.faciletechnolab.com), we help our client [build SaaS software](https://www.faciletechnolab.com/software-development-services/saas-development-services). We are grateful to have an opportunity to help **five such clients** so far in last **three years**.

Subscribe to get latest updates on Software or Software-as-a-Service (SaaS) related topics right in your inbox.
How to enable HTTP/2 on NGINX
Tags: nginx, ubuntu, http2, howto
Published: 2023-04-11 10:01:21

---
title: How to enable HTTP/2 on NGINX
published: true
date: 2023-01-10 00:00:00 UTC
tags: nginx,ubuntu,http2,howto
canonical_url: https://driesdeboosere.dev/blog/how-to-enable-http2-on-nginx/
---

In this post, I'll explain how you can setup your NGINX for HTTP/2.

Go to your `nginx.conf` or `default` configuration file. In my case I'll need to change my NGINX default configuration file;

```
nano /etc/nginx/sites-available/default
```

This should look something like this;

```
server {
    listen 80;
    server_name driesdeboosere.dev *.driesdeboosere.dev;
    location / {
        proxy_pass http://127.0.0.1:5000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection keep-alive;
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }

listen [::]:443 ssl ipv6only=on; # managed by Certbot
listen 443 ssl; # managed by Certbot
ssl_certificate /etc/letsencrypt/live/driesdeboosere.dev/fullchain.pem; # managed by Certbot
ssl_certificate_key /etc/letsencrypt/live/driesdeboosere.dev/privkey.pem; # managed by Certbot
include /etc/letsencrypt/options-ssl-nginx.conf; # managed by Certbot
ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem; # managed by Certbot
}
```

Add `http2` after `ssl`:

```
listen [::]:443 ssl http2 ipv6only=on; # managed by Certbot
listen 443 ssl http2; # managed by Certbot
```

Now save your changes to the NGINX config file and reload NGINX:

```
systemctl reload nginx
```

Well done! Now your NGINX server uses HTTP/2!
Creating a React Counter
Published: 2023-01-09 23:52:56

Hello everyone, welcome to my blog. I am currently a student at Altschool and for my first technical assignment, I would like to take you through my beginner friendly process for creating a counter app with useReducer hook. This was really a test of my understanding of hooks.

Firstly, my focus was on creating the hooks. I created a hook which was based on using the switch-case.
![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/5x7u8g6ykips29smxr4j.png)

Then I used that logic to create a custom hook which I could use the dispatch function in.

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/rx9bo0kvlscupuv58fe1.png)

My next focus was creating two components using the useState that was converted to a custom hook. 

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/lli1hrbs2pn89wjwobcd.png)

The second counter was then created using the useReducer hook I had worked on earlier.

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/esm41ct7q6zxbd9ocnu2.png)

Lastly, I worked on Error boundary.
![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/07twzir5oe8fg5u6820m.png)