Reviewing Your Website Designs Live - with Gary Simon

Curriculum for the course Reviewing Your Website Designs Live - with Gary Simon

Gary Simon reviews viewer's website designs live. Submit a design for Gary to review by tweeting it with the hashtag #LiveUIUXReview. Gary runs the DesignCourse YouTube channel: https://www.youtube.com/channel/UCVyRiMvfUNMA1UPlDPzG5Ow -- Learn to code for free and get a developer job: https://www.freecodecamp.org Read hundreds of articles on programming: https://freecodecamp.org/news And subscribe for new videos on technology every day: https://youtube.com/subscription_center?add_user=freecodecamp

Watch Online Full Course: Reviewing Your Website Designs Live - with Gary Simon

Click Here to watch on Youtube: Reviewing Your Website Designs Live - with Gary Simon

This video is first published on youtube via freecodecamp. If Video does not appear here, you can watch this on Youtube always.

Udemy Reviewing Your Website Designs Live - with Gary Simon courses free download, Plurasight Reviewing Your Website Designs Live - with Gary Simon courses free download, Linda Reviewing Your Website Designs Live - with Gary Simon courses free download, Coursera Reviewing Your Website Designs Live - with Gary Simon course download free, Brad Hussey udemy course free, free programming full course download, full course with project files, Download full project free, College major project download, CS major project idea, EC major project idea, clone projects download free

Repo experience survey results

A couple of months ago we ran a survey of our github community to understand our users satisfaction and experience with the mechanics of how the projects are open-sourced with the community. We typically have been looking at the features and satisfaction with our products themselves – this was different because it’s about how the community experiences the project through the lens of the github repos.

Response rate and Repos

We advertised the survey in repos and on our blog and got 191 responses. Most folks arrived from dotnet/announcements (likely from the blog) rather than from sticky posts in repos. Note that we asked respondents to choose one primary repo to answer questions for.

Q1. Which .NET repo do you interact / work with the most? (pick one)

For the rest of the results – only five repos had enough responses to call out the responses on a per repo basis. Before you question if my math is off – the “Grand Total” row includes the results for all the repos including the other repos that are not individually called out.

Satisfaction

The overall satisfaction with repos is good with one exception.

Q3. Overall, how do you rate your experience with the repo you selected?

Q5. How satisfied were you with the responsiveness and engagement of the repo maintainers?

WPF was the main outlier for satisfaction. Drilling into the comments, the main concern was that PRs and issues were not being addressed by the maintainers and there was a lack of clarity on if and when they would be. Internally the WPF team was not sufficiently staffed and did not have the test infrastructure in place to be able to respond to the community contributions. The WPF team appreciates the feedback, and published an updated roadmap and community contribution guidelines to increase transparency with the community back in July. The team is still focused on finishing up .NET 5.0 as per the published roadmap and will share updates on the plan for increasing community engagement on PRs and issues early in the .NET 6.0 release.

Repo Activity

Earlier in the year, we consolidated into a smaller number of repos. We hoped this would make it easier to find the repo they needed. The survey shows that for the most part, people are able to find the correct repo.

Q2. How easy was it to find the repo you needed?

Browsing the code is the most common repo activity. About half of the respondents have filed issues or cloned and tried to build repos.

Q4. Which of the following activities have you done with this repo in the last 90 days?

For those who have filed issues or PRs, the overall satisfaction is high, except for WPF as noted above.

Q6. How satisfied are you with the outcome of the issue or PR(s)?

And for those who did try and build the repo, they were mostly successful, but in many cases it took significant effort.

Q9. If you built the repo locally, were you successful?

Since this survey, we have made incremental efforts to make build easier and better documented. Going forward, we are investigating whether we can take advantage of Github CodeSpaces to help contributors quickly configure a workspace in the cloud. Tooling that is being built to configure the codespaces environment can also be used to configure your local machine.

Working with PRs

In most repos, almost everyone that submitted a PR saw it successfully merged.

Q7. Have you tried to submit a change to the code in the repo you selected above?

They were able to find the right place in the code to make the fix.

Q10. Finding the right place in the code to make the fix

However, we need to make it easier to run tests and debug your changes. This is an area that we will be spending more time upon: for example, in dotnet/runtime we are migrating to vstest to improve the experience in the Visual Studio Test Explorer

Q11. Running tests against the fix

Q12. Ability to debug the code

Inclusion and welcoming-ness

We want .NET to feel welcoming to everybody, and provide a community where people can discuss ideas and problems in a respectful and collaborative way. Thankfully, it seems that most people feel welcome and included.

Q14. Thinking about the community in this repo, How would you rate the friendliness and helpfulness of others in the repo?

To gauge how the .NET community compares to others, we also asked:

Q15. How welcome do you feel in this repo compared to other OSS projects out there?

This shows that there is still work to do. If you have ideas or suggestions for how we help make our communities more inclusive and welcome, please reach out to any of the repo maintainers – we want everyone to feel free to participate or contribute. As always if you witness, or are subjected to behavior contrary to the code of conduct, then please contact conduct@dotnetfoundation.org or opencode@microsoft.com to report any issues.

Freeform comments

When creating the survey, we wanted to make most questions multiple choice as that makes the survey simpler to complete and increases the response rate. We had one question with freeform text to collect additional feedback:

Q16 If we could do one thing to improve your experience in this repo what would it be?

A number of themes stuck out. Some anonymized examples:

Building the source code

• A clear beginner guide to building the source code would be welcome. Even as a 8 year professional dev I had trouble figuring out I needed the latest nightly SDK to run things.
• Make the build process easier
• The build steps are highly complicated and require multiple execution loops until everything build since they can’t be build from VS directly. It also requires knowledge of the ps-scripts that are used to build the system, which is distributed between multiple wiki pages. It’s also not really clear how the “subsystems” interact with each other and why some can be build as Debug and others as Release. The docs seem to explain a lot but seem to be primarily geared towards devs internal to MS or that already have significant experience in those fairly low-level projects. It would be nice to streamline both the instructions and the docs.
• Make it easier to build, test & debug. It’s hard to know which script/command to run, so many options. Should be able to just run dotnet build …
• I would say the most annoying thing about contributing is definitely the fact that you can’t use the standard `dotnet` installed on your device when you build. This has negative impact on integrating with Visual Studio products and also building from the command line It is definitely a bit annoying having to run `build.sh` and having to use the `.dotnet/dotnet.exe` that this installs. Basically, would be great to align the experience using `dotnet` tools to create our own class libraries with how we build dotnet/* projects. The recent strides towards getting `dotnet test` to work is a great example of this.

Lower the barriers to contributing

• I would love it if there was an online remote program that I could participate and I’ll be guided by the team and do some important contribution to the code.
• I really want to contribute, but the good-first-issues are few and far between, and if I’m not watching them constantly they’ll get scooped up. It’s really discouraging when I want to be a part of the community, but I struggle to find something that is at my relative skill level easily.
• I notice that some times new contributors become impatient after submitting a PR, so a way of setting expectations in advance, or just a short message after submitting the PR would be helpful.
• Clarify the lifecycle of an issue, and give better implementation instructions on up-for-grabs issues. Some up-for-grabs mean writing out description etc.
• As someone who has open source experience and .net experience, I think it is hard to do the first steps. I browsed several times through the issues but did not find a good one for beginner. Those tagged with “easy” in dotnet/runtime are mostly very old. I think it would be good, fi there are issues that are really for beginners and whose description make it as easy as possible to understand what is going on.
• Remember that when responding to questions/issues you guys work in the Repo every day and are experts in the area. Most of us asking questions don’t have that level of expertise in the area – hence, the reason for the question. Thus, having patience and answering questions in a robust and well stated way is of most benefit to the community – instead of short, terse answers/responses. Try to better the community by sharing the expertise and have patience with those that are lacking it.

Timely responses to issues and PRs

• Responsiveness from the maintainers of the repo.
• More engagement with issues. A guaranteed triage process that responds within a few days that either puts the ball back in my park with something actionable (e.g. “Here’s what won’t work about your API proposal”), or acknowledges that the ball is in the team’s park and sets an expectation of a aspirational timeframe in which the team will review the issue and provide feedback. E.g. next design review a week from now, after the push for X is done in a month or two, etc. It’s fine to stress that the timeframe is not a promise and is only aspirational, but the main thing is this: Silence is a little demoralizing.
• Sometimes PRs sit for months with no activity, would be great to merge PRs if there’s nothing blocking them
• respond, respond, respond

Understanding the repo structure and changes

• I’ve found it difficult since all the small repos were merged into the big ones that exist now. Lots of online resources have links to the old repos, and it’s much harder searching because you tend to get false positives with common words.
• Since roslyn can be a bit large and intimidating to new contributors, if possible, try to find a way to document the purpose of each project and maybe provide a way to make it easier to find out where to make code changes.
• Merging corefx and corert has made it much harder to follow what is going on at the framework level as opposed to the runtime level. I have limited time to watch the repo, and now a lot of it is spent sorting the wheat from the chaff. While I understand the technical reason for the merger, it really makes things harder for the little guy.
• As a developer interested in the progress made only on the BCL I find it extremely frustrating to sort through BCL and CLR issues/PRs in the dotnet/runtime repo. I would like a clear distinction between those. A label I could filter by would be a good start.
• It would be nicer if the C++ codes for JIT/GC/etc had more comments to help people understand better.

Action Items

Based on the survey feedback we are working on the following to improve the experiences:

• Tooling to make it easier to setup your local or a cloud environment to be able to clone, build, run tests and debug the code from the .NET repos. We will also continue to incrementally improve the experience of building, debugging and testing in the repos.
• Published a roadmap for WPF and working on staffing and tooling to be able to take PRs
• Creating internal dashboards to track the (meaningful) response time to Issues and the time taken to merge community PRs, to ensure they are all being examined and triaged by their respective teams.

We will be running another version of this survey in the fall, to track progress, and include more repos from other parts of the “Developer Division” family.

Thank you to all who took the time to respond. We really do appreciate the feedback. If you have more thoughts and feedback, use the comments below or reach out directly.

The post Repo experience survey results appeared first on .NET Blog.

source https://devblogs.microsoft.com/dotnet/repo-experience-survey-results/

JavaScript Tutorial: Build Flappy Bird and Doodle Jump

Popular Game Development Tutorial using Javascript

Popular Game Development Tutorial using Javascript

In this video, you will practise over 32 of JavaScripts most popular methods in order to build the two games. This includes .forEach(), .push(), .shift(), .addEventListener(), .appendChild(), while loops, Classes, constructors and many more.

• ✏️ Course created by Ania Kubow.
• 🎥 Ania's YouTube Channel: https://www.youtube.com/aniakubow
• 🐦 Ania's Twitter: https://www.twitter.com/ania_kubow

Flappy Bird & Doodle Jump Javascript Tutorial

Course Contents

• (00:00) Introduction
• (01:54) Introduction to Doodle Jump
• (01:56) Doodle Jump game logic
• (03:34) Setting up our game
• (07:37) Creating our doodler
• (12:02) Creating our platforms
• (15:02) Creating our Platform Class
• (19:53) Moving our platforms
• (23:12) Making our doodler jump
• (22:40) Making our doodler fall
• (27:21) Writing our game over logic
• (30:54) Hooking up our keyboard keys
• (38:21) Making our doodler go left and right
• (44:57) Removing and adding new platforms using array work
• (48:49) Removing all children of the grid using a while loop

• (49:41) adding the score

• (51:42) Flappy Bird introduction

• (51:44) Flappy Bird game logic
• (52:08) Setting up our project
• (57:55) Writing our start game logic
• (1:00:35) Making our bird jump
• (1:03:01) Hooking up our keyboard keys
• (1:04:04) Generate a pipe obstacle
• (1:09:04) Move the obstacle
• (1:11:34) Generate new obstacles using setInterval() and setTimeout()
• (1:13:06) Write our game over logic
• (1:18:53) We learn how to add images to our project
• (1:22:37) We expand our collision rules using && and ||
• (1:25:01) We add the final stages of styling learning about z-index

-- Learn to code for free and get a developer job: https://www.freecodecamp.org Read hundreds of articles on programming: https://freecodecamp.org/news And subscribe for new videos on technology every day: https://youtube.com/subscription_center?add_user=freecodecamp

Watch Online Full Course: JavaScript Tutorial: Build Flappy Bird and Doodle Jump

Click Here to watch on Youtube: JavaScript Tutorial: Build Flappy Bird and Doodle Jump

This video is first published on youtube via freecodecamp. If Video does not appear here, you can watch this on Youtube always.

Udemy JavaScript Tutorial: Build Flappy Bird and Doodle Jump courses free download, Plurasight JavaScript Tutorial: Build Flappy Bird and Doodle Jump courses free download, Linda JavaScript Tutorial: Build Flappy Bird and Doodle Jump courses free download, Coursera JavaScript Tutorial: Build Flappy Bird and Doodle Jump course download free, Brad Hussey udemy course free, free programming full course download, full course with project files, Download full project free, College major project download, CS major project idea, EC major project idea, clone projects download free

ML.NET September Updates

ML.NET is an open-source, cross-platform machine learning framework for .NET developers. It enables integrating machine learning into your .NET apps without requiring you to leave the .NET ecosystem or even have a background in ML or data science. ML.NET provides tooling (Model Builder UI in Visual Studio and the cross platform ML.NET CLI) that automatically trains custom machine learning models for you based on your scenario and data.

This release of ML.NET (1.5.2) brings numerous bug fixes and enhancements, while tooling updates include the ability to train object detection models using Azure ML via Model Builder. You can now also locally train image classification models with the ML.NET CLI.

In this post, we’ll cover the following items:

1. Object detection in Model Builder
2. Image classification in ML.NET CLI
3. ML.NET 1.5.2
4. Feedback
5. Get started and resources

Object detection in Model Builder

Object detection is a computer vision problem. While closely related to image classification, object detection performs image classification at a more granular scale. Object detection both locates and categorizes entities within images. Use object detection when images contain multiple objects of different types.

 

 

 

 

 

 

 

 

 

 

Some use cases for object detection include:

• Self-Driving Cars
• Robotics
• Face Detection
• Workplace Safety
• Object Counting
• Activity Recognition

While previously ML.NET offered the ability to consume pre-trained TensorFlow and ONNX models for object detection via the ML.NET API, you can now use Model Builder in Visual Studio to train custom object detection models with the power of Azure and AutoML.

After selecting the object detection scenario and setting up your Azure ML workspace in Model Builder, you must input your data. Currently, Model Builder does not offer a way to annotate images, so you must use an external tool to draw bounding boxes around objects in your training images.

If you need to label your images, we recommend trying out VoTT, an open source annotation and labeling tool for image and video assets.

After downloading VoTT, you can create a new VoTT project and choose a dataset from your Local File System (Azure Blob Storage and Bing Image search are also options, but Model Builder currently only supports training from a local dataset). This is simply a folder that contains all the images that you’d like to annotate.

After selecting the folder path to your dataset of images for your Source Connection, you can then choose an output folder for the Target Connection.

You can skip the Video Settings, and then add in your Tags (any objects that you want to be detected in your images):

After saving your project, all images found in the Source Connection folder will appear, and you can start labeling your images like this:

When you’re done labeling, you can go to the Export section (4th icon down on the left toolbar), select “VoTT JSON” as the Provider and “Only tagged Assets” as the Asset State (Include images is optional). When you hit Save Export Settings, the VoTT JSON will be generated in the Target Connection folder that you specified during VoTT project creation.

The VoTT JSON looks like this:

You can then use this VoTT JSON as the dataset input for the Data step in Model Builder.

Model Builder currently only accepts the format of JSON generated by VoTT, but we plan to add support for more formats in the future. If there is a dataset format for object detection that you’d like to see supported in Model Builder, leave your feedback on GitHub.

After inputting your data and moving to the Train step in Model Builder, you can hit Start training, which uploads your data to Azure and begins the training with Azure ML. When training is finished, your trained ML.NET model is downloaded so that you can test it out locally.

In the Evaluate step, you can see your model’s accuracy as well as make predictions on test images:

The score shown on each detected bounding box indicates the confidence of the detected object. For instance, in the screenshot above, the score on the bounding box around the cat indicates that the model is 77% sure that the detected object is a cat.

The score threshold, which can be increased or decreased with the threshold slider, will add and remove detected objects based on their scores. For instance, if the threshold is .51, then the model will only show objects that have a score / confidence of .51 or above. As you increase the threshold, you will see less detected objects, and as you decrease the threshold, you will see more detected objects.

Once you are satisfied with your model’s performance, you can generate the model and consumption code in the Code step in Model Builder and integrate your model into your end-user application.

Image classification in ML.NET CLI

In addition to classification, regression, and recommendation, you can use the cross-platform ML.NET CLI to locally train custom image classification models.

All you need for this scenario is dataset of images that you’d like to use for training. For instance, let’s look at the weather example, where you want to classify an image as rainy, cloudy, or sunny.

First you need to make sure you have your images in the correct format, which is a folder that organizes the photos into separated labeled sub-folders like this:

In this case, each folder contains 30 images of the corresponding weather.

Once you have your dataset, you can use the following command in the ML.NET CLI to start training:

mlnet image-classification --dataset “Weather-Small”

When training is done, the CLI will output the accuracy of your model and will generate the necessary projects for model consumption and re-training:

ML.NET 1.5.2

Last month we announced ML.NET 1.5.1, which had a regression that is fixed with ML.NET 1.5.2. Thus, we recommend that you skip 1.5.1 and update to 1.5.2.

This release also closed over 30 reported bugs and added ONNX enhancements to support more types for ONNX export.

You can see more in the 1.5.2 release notes.

Feedback

We would love to hear your feedback!

If you run into any issues, please let us know by creating an issue in our GitHub repos (or use the new Feedback button in Model Builder!):

• ML.NET API
• ML.NET Tooling (Model Builder & ML.NET CLI)

Get started and resources

Get started with ML.NET in this tutorial.

Learn more about ML.NET and Model Builder in Microsoft Docs.

Tune in to the Machine Learning .NET Community Standup every other Wednesday at 10am Pacific Time.

The post ML.NET September Updates appeared first on .NET Blog.

source https://devblogs.microsoft.com/dotnet/ml-net-september-updates/

NET Core Releases and Support

While we’ve covered .NET Core releases, cadence and support policies in previous blog posts, the information has been distributed across a couple of individual posts. With the .NET 5 release just around the corner, we thought this is a good time to bring all the information together into a single post as a refresher on these topics.

As we’ve covered previous posts, .NET Core releases have a very different model relative to .NET Framework so if you’re coming from .NET Framework application development and familiar with that, or just starting with .NET Core it is important to understand the release cadence, types, and support lifecycle for .NET Core so you can make the right choices for your situation.

 

Key Highlights

.NET Core ships major releases, minor releases, and servicing updates (patches). From a support perspective, there are 2 support “tracks” for .NET Core releases.

• The first track is “Current” releases – these .NET Core versions are supported for a period of 3 months after the next major or minor release ships.
• The second track is “Long Term Support” or LTS releases – these are supported for a minimum of 3 years, or 1 year after the next LTS release ships (whichever is longer).

.NET Core releases alternate between LTS and Current releases, so it is possible for an “LTS” release that shipped first (for example .NET Core 3.1) to be supported for longer than a “Current” release (for example .NET 5) that shipped later.

Servicing updates ship monthly for the most part and include both security and non-security (reliability, compatibility, and stability) fixes. .NET Core servicing releases are supported from the time they are released until the next servicing update is released. Servicing updates leverage runtime roll forward behavior, that is applications default to running on the latest installed runtime servicing update that is installed, so we take care to ensure a high degree of compatibility in servicing updates. When it comes to getting support for .NET Core, you have a choice between Microsoft assisted support and Community support based on your situation.

 

The rest of this post covers these areas in more detail:

• .NET Core Release Types – major releases, minor releases, servicing releases, and SDK feature bands
• .NET Core Lifecycle – modern lifecycle, Current releases, and Long Term Support (“LTS”) releases
• Getting support from Microsoft and the Community
• End of Support and Operating System support
• .NET Roadmap

 

.NET Core Release Types

.NET Core ships major releases, minor releases, and servicing updates (patches).  Information about the release is encoded in the version associated with the release in the form of major.minor.patch.

For example,

• .NET Core 3.0 is a major release of the product.
• .NET Core 3.1 is the first minor release after the .NET Core 3.0 major release.
• .NET Core 3.1.7 has a major version of 3, minor version of 1 and patch update version of 7, that is, it’s the seventh patch for .NET Core 3.1.

Major releases

Major releases of .NET Core like .NET Core 2.0, 3.0 or .NET 5.0 generally include new features/functionality, new public surface area, and bug fixes. Due to the nature of the changes, these releases are expected to have breaking changes. All major releases install side by side with all previous major releases.

Minor releases

Minor releases of .NET Core like .NET Core 2.1 and 3.1 also include new features/functionality, public surface area, bug fixes, and may also have breaking changes. The difference between these and major releases is that the magnitude of the changes is generally smaller and therefore an application upgrading from .NET Core 3.0 to 3.1 has a smaller jump to move forward. Minor releases install side by side with all previous minor releases.

Servicing Updates

Servicing updates for .NET Core ship almost every month and these updates carry both security and non-security bug fixes. For example, .NET Core 3.1.8 is the eight update for .NET Core 3.1. When these updates include security fixes, they’re released on “patch Tuesday”, which is always the second Tuesday of the month and predictable. Servicing updates are expected to maintain compatibility and we take steps to ensure this. Starting with .NET Core 3.1, servicing updates are upgrades, that is, the latest servicing update for 3.1 will remove the previous 3.1 update upon successful installation.

Feature Bands (SDK only)

Versioning for the .NET Core SDK works slightly differently from the .NET Core runtime. .NET Core SDK updates sometimes includes new features or new versions of components like MSBuild and NuGet to align with new Visual Studio releases. These new features or components may be incompatible with the versions shipping in previous SDK updates for the same major/minor. Hence feature bands exist as a means of differentiating across such SDK updates.

The .NET Core SDK uses the concept of feature bands. For example, the first .NET Core 3.1 SDK was 3.1.100. This release corresponds to the 3.1.1xx  “feature band”. Feature bands are defined in the hundreds groups in the third section of the version number. For example, 3.1.101 and 3.1.201 are versions in two different feature bands while 3.1.101 and 3.1.199 are in the same feature band. When .NET Core SDK 3.1.101 is installed, .NET Core SDK 3.1.100 will be removed from the machine if it exists. When .NET Core SDK 3.1.200 is installed on the same machine, .NET Core SDK 3.1.101 won’t be removed.

 

Runtime Roll-forward and Compatibility

Major and minor updates install side by side with previous versions and an application built to target a specific major/minor version continues to use that targeted runtime even if a newer version is installed, that is, the app does not automatically roll forward to use a newer major/minor version of the runtime unless you opt-in for this behavior. An application that was built to target .NET Core 3.0 will not automatically start running on .NET Core 3.1. In general, we recommend rebuilding the app and testing against a newer major or minor runtime version before deploying this to production. For more information, see Runtime Roll Forward.

Servicing updates are treated differently from major and minor releases. An application built to target .NET Core 3.1 targets the 3.1.0 runtime by default and automatically rolls forward to use a newer 3.1.1 runtime when that servicing update is installed unless you opt-out from this roll forward behavior. We default to this behavior because we want security fixes to be used as soon as they’re installed without any other action needed.

 

.NET Core Lifecycle

Fixed versus Modern lifecycle

The first thing to understand is that .NET Core adopts the modern lifecycle, which is very different from the traditional fixed lifecycle that has been used for .NET Framework releases. Products with fixed lifecycles like the .NET Framework as the name implies provide a fixed period of support, this is typically long, for example, 5 years of mainstream support (including security and non-security hotfixes) and another 5 years of extended support (security fixes only). Products like .NET Core that use a modern lifecycle typically adopt a more service-like support model that is shorter and ship more frequently.

From a support perspective, there are 2 flavors of support “tracks” for .NET Core major (and minor) releases. Each has its unique attributes and may be appropriate in different situations.

Current Releases

These .NET Core versions are supported for a period of 3 months after the next major or minor release ships.

Example:

• .NET Core 3.0 shipped in September 2019 and was followed by .NET Core 3.1 in December 2019.
• .NET Core 3.0 support ended in March 2020 (that is, 3 months after 3.1, the successor to 3.0 shipped)

Long Term Support (“LTS”) releases

These are supported for a minimum of 3 years, or 1 year after the next LTS release ships (whichever is longer).

Example:

• .NET Core 2.1 was released in May 2018 and was deemed an LTS release in August 2018, so it will be supported for 3 years (i.e. August 2021), or 1 year after the next LTS release, whichever is longer.
• The next LTS after 2.1 was 3.1 and this was released December 2019 (i.e. 1 year from this would be Dec 2020)
• Since August 2021 is later than Dec 2020 .NET Core 2.1 will be supported through August 2021.

It is possible for an older LTS release to be supported for longer than a newer Current release.

For example.NET Core 2.1 is an LTS release and will be supported through August 2021. .NET Core 3.0, which shipped later in September 2019, went out of support in December 2019.

Here’s a picture that shows the support lifecycle for various .NET Core releases. Note that this includes .NET 5.0 and releases in the future, so they’re for demonstrative purposes only. The specific lifecycle dates will be published at the time the releases ship.

If you’re building a service and expect to continue updating it on a regular basis, then a .NET Core “Current” release like .NET 5.0 may be your best option to stay up to date with the latest features .NET Core has to offer.

On the other hand, if you’re building a client application that will be distributed to consumers and this application needs to be supported for a certain period before the consumer can be reasonably expected to upgrade to the next version of this application, then picking an LTS release like .NET Core 3.1 or .NET 6.0 might be the right option.

 

Servicing releases

.NET servicing releases are supported from the time they are released until the next servicing update is released. The release cadence is typically monthly. This means you need to regularly install servicing releases to ensure that your apps are in a secure and supported state.

For example, if the latest servicing release for .NET Core 3.1 is 3.1.8 and we ship 3.1.9, then 3.1.8 is no longer the latest and the supported servicing level for 3.1 is 3.1.9.

More information about the latest shipped servicing updates for all supported versions of .NET Core can be found on the .NET Core Downloads page.

 

Getting Support

Microsoft Support

For assisted support with .NET Core technologies, contact a Microsoft Support Professional.

You need to be on a supported servicing level (the latest available servicing update) to be eligible for support. If a system is running 3.1 and the 3.1.8 servicing update has been released, then 3.1.8 needs to be installed as a first step.

 

Community Support

Community support is another great way to get help and even contribute to projects. See our Community page for details.

 

.NET Core versions and support

Here’s a snapshot of the end of support date for the various versions of .NET Core. For the most current information you can refer to the .NET Core support policy page.

Version	Original Release Date	Latest Patch Version	Patch Release Date	Support Level	End of Support
.NET Core 3.1	December 3, 2019	3.1.8	September 8, 2020	LTS	December 3, 2022
.NET Core 3.0	September 23, 2019	3.0.3	February 18, 2020	EOL	March 3, 2020
.NET Core 2.2	December 4, 2018	2.2.8	November 19, 2019	EOL	December 23, 2019
.NET Core 2.1	May 30, 2018	2.1.22	September 8, 2020	LTS	August 21, 2021
.NET Core 2.0	August 14, 2017	2.0.9	July 10, 2018	EOL	October 1, 2018
.NET Core 1.1	November 16, 2016	1.1.13	May 14, 2019	EOL	June 27 2019
.NET Core 1.0	June 27, 2016	1.0.16	May 14, 2019	EOL	June 27 2019

 

End of support

End of support refers to the date after which Microsoft no longer provides fixes, updates, or technical assistance for a particular product version. As this date nears, make sure you have moved to using a supported version and have the latest servicing update installed. If you continue to use a version that is out of support, you’ll no longer receive security updates that will be required to protect your applications and data.

.NET Core support and Operating Systems

.NET Core can be run on a range of operating systems. Each of these operating systems has a lifecycle defined by its sponsor organization (for example, Microsoft, Red Hat, or Apple). The .NET Core team applies each of those lifecycle schedules to inform adding and removing support for operating system versions.

When an operating system version goes out of support, we stop testing that version and providing support for that version. Users need to move forward to a supported operating system version to get support.

 

.NET Roadmap

.NET Core is where new investments in .NET are happening. New applications that want to take advantage of the new features in .NET should consider moving to .NET Core.

Here’s our planned release cadence for .NET Core.

We will ship .NET Core major releases every year, with every alternate release designated as a Long Term Support (“LTS”) release. .NET Core 3.1 is an LTS release and the next one will be .NET 6.0, shipping around November 2021. The one after that will be .NET 8.0 shipping November 2023, and so on. A relevant point worth calling out is that .NET 5.0 is not an LTS release.

 

.NET Framework

As we’ve covered in previous blog posts, .NET Framework 4.8 was the last major release of the .NET Framework. If you have existing .NET Framework applications that you’re maintaining, there is no need to move these applications to .NET Core. We’ll continue to support and service .NET Framework for bug fixes – reliability and security fixes. .NET 4.8 continues to ship with Windows and will be supported with new releases of Windows. For compatibility reasons, there are no plans to remove .NET Framework 4.8 from Windows.

 

Summary

If you’re using an out of support .NET Core runtime like 1.x, 2.0, 2.2, or 3.0, we strongly recommend you update your application to a supported version like 3.1, so you can benefit from the security updates and other non-security fixes we ship in our monthly updates.

See our blog post on the .NET 5.0 RC1 release for the latest bits and to give this a spin.

 

The post NET Core Releases and Support appeared first on .NET Blog.

source https://devblogs.microsoft.com/dotnet/net-core-releases-and-support/

Visual Studio Code Crash Course

Curriculum for the course Visual Studio Code Crash Course

Visual Studio Code (VS Code) is a free code editor made by Microsoft. In this course you will learn how to use this popular code editor. You will also learn tips and tricks to make it even easier to use. ✏️ This course was created by James Q Quick. Check out his channel: https://www.youtube.com/c/jamesqquick 🔗 VS Code cheat sheet: https://learn.jamesqquick.com/vs-code-cheat-sheet -- Learn to code for free and get a developer job: https://www.freecodecamp.org Read hundreds of articles on programming: https://freecodecamp.org/news And subscribe for new videos on technology every day: https://youtube.com/subscription_center?add_user=freecodecamp

Watch Online Full Course: Visual Studio Code Crash Course

Click Here to watch on Youtube: Visual Studio Code Crash Course

This video is first published on youtube via freecodecamp. If Video does not appear here, you can watch this on Youtube always.

Udemy Visual Studio Code Crash Course courses free download, Plurasight Visual Studio Code Crash Course courses free download, Linda Visual Studio Code Crash Course courses free download, Coursera Visual Studio Code Crash Course course download free, Brad Hussey udemy course free, free programming full course download, full course with project files, Download full project free, College major project download, CS major project idea, EC major project idea, clone projects download free

Azure Static Web Apps with .NET and Blazor

Azure Static Web Apps is a service that automatically builds and deploys full stack web apps from a GitHub repository. Azure Static Web Apps consist of a static web frontend, and an Azure Functions based backend. When you create a Static Web Apps resource, Azure sets up a GitHub Actions workflow in the app’s source code repository that monitors a branch of your choice. Every time you push commits to the watched branch, the GitHub Action automatically builds and deploys your app and its API.

As of today, Azure Static Web Apps now has first-class support for Blazor WebAssembly and .NET Functions in preview, available in all supported regions. This was one of the top user requests since Static Web Apps was announced at Build. You can develop and deploy a frontend and a serverless API written entirely in .NET.

Let’s give it a try!

Getting Started

To help you get started, we’ve created a GitHub repository template, which you can use as a starting point for your own projects.

In GitHub, click on the Use this template button to create a new GitHub repository using the template, providing it a name of your choosing (we’ll use my-blazor-app here) and click Create repository from template.

There are three folders in the template:

• Client: The Blazor WebAssembly sample application
• API: A C# Azure Functions API, which the Blazor application will call
• Shared: A C# class library with a shared data model between the Blazor and Functions application

To run the app locally, start both the API and Client projects. The “Fetch data” page in the Blazor app requests weather forecast data form the backend Function API and display it on the page.

To run the app from the command-line, you’ll need to install the Azure Functions Core Tools for your platform of choice.

Deploying to Static Web Apps

To deploy this app as an Azure Static Web App, log into your Azure account (sign up for a free one here) and search for Static Web Apps.

Click Create, provide a Subscription, Resource Group and name for the application.

Next, sign into GitHub and locate your GitHub repo (my-blazor-app) and select the branch you wish to deploy.

Finally, select Blazor from the Build Presets, which will populate the App location, API location and App artifact location with Client, API and wwwroot. The first and second values are the path within the Git repository to where the project files for the Blazor and Functions app resides, so if you’ve modified the structure of the Git repository, make sure these values are updated to reflect. The third value is the output path that Blazor will compile into and doesn’t need updating.

Complete the wizard and Static Web Apps will create the GitHub Actions workflow file for you and deploy your application to Azure.

Summary

We started by forking a GitHub repository (but you could’ve also used a project created in Visual Studio/Visual Studio Code/etc.), created a Static Web App in Azure, and it setup a GitHub Actions workflow for us, automatically building and deploying our Blazor and Functions application. We’ve now got a statically hosted application with a serverless backend, ready to scale for our demands.

Additional Resources

To learn more about Blazor WebAssembly and .NET Functions on Static Web Apps, check out the quickstart docs, the Microsoft Learn module, as well as the comprehensive Static Web Apps docs.

Give Feedback

We’re excited to have Blazor WebAssembly and .NET Functions supported by Azure Static Web Apps, and can’t wait to see what you build with them. Let us know what you think by filing an issue on GitHub.

The post Azure Static Web Apps with .NET and Blazor appeared first on ASP.NET Blog.

Using GitHub Codespaces with .NET Core

In May of this year we announced Visual Studio Codespaces and early support for .NET Core developers.  Since then we’ve had some early adopters try it out and they gave us great feedback.  We’ve made a bunch of progress on enabling more in the Codespaces capabilities as well.  We’ve also made some fundamental changes as we are now GitHub Codespaces!  Just a few weeks back, Allison wrote about how Visual Studio Codespaces is consolidating into GitHub Codespaces explaining the transition to a single service and experience for Visual Studio developers and other developers connecting to the Codespaces service.

You can read more about general Codespaces experience updates on the Visual Studio blog.   There are some great new changes like the ability to specify some more initialization setup information in your repo so developers can rapidly get started when connecting to your code! The .NET team wanted to share a few brief updates of our own specifically about some of the capabilities we’ve enabled for developers connecting to Codespaces!

Azure Functions support

Initially we enabled support for writing .NET Core applications targeting class library, console, and web applications.  We have expanded to enable running and debugging Azure Functions projects. We’ve also provided you with the ability to run more of your complete solution. For example, you can run a front-end ASP.NET application with a serverless backend all from a Codespace.

Editing, debugging, and testing

We know that the key to your Visual Studio experience is being productive in the editor and we’ve enabled more of those great features in Codespaces environments now as well.  A few of the additions we’ve enabled when connected to a Codespace are:

• Project Context information in top Navigation Bar
• Partial support for diagnostics, completion, quick info, and smart indent in HTML, CSS, and Razor
• Most scenarios are now supported such as Find All References, Find in Files, Go to Declaration, Go to Implementation, etc. including support for navigating from C# to Razor
• Secondary menus of lightbulbs such as setting severity and changing code style rules from the editor are now supported
• Format document
• Doc comment support both during typing ‘///’ above a method/class, and when pressing enter within a doc comment.

Of course, part of development isn’t just writing the code, but finding the bugs we create, right?  We’ve now added the following test and debug capabilities:

• Test Explorer functionality is more complete including test outcome filters, run failing tests, run last test run, etc.
• Basic debugger stepping is supported
• Locals, autos, watch windows with highlighting what is in search box is now supported

Publishing your project

We know that a lot of Visual Studio developers use Publish for various reasons and we’ve enabled the Publish experience when in Codespaces.  In this update, we’re previewing a new capability in the Publish experience for deploying to Azure to help you get your builds more automated in a CI/CD flow using GitHub Actions.  When you publish now you’ll see a new option to create a GitHub Actions workflow for your repo that will automatically build and deploy your app to the Azure resource you selected.

This workflow can easily be modified to accommodate various configurations or different triggers (like on push or pull request) that you may want to implement.  We’d love for you to try this out and give us feedback.

Coming in the Future

In the future we are continuing to enable more for .NET Core developers including:

• Scaffolding for ASP.NET Core projects
• Publishing directly to Azure and other hosting targets
• Managing Azure Service dependencies for .NET Core projects.
• Creating new Functions projects and Function endpoints (items)

And of course more features will be prioritized based on your feedback.  We encourage you to read the Codespaces documentation to learn more about what is supported and what is still in progress for your development needs.

How do I try out Codespaces?

We’re glad you asked!  For .NET Core developers we are still in a private preview state as we build up support for more scenarios and learn various configuration needs from you all.  But we’re looking for more customers to on-board to the service and who can commit to providing some feedback for us to improve the experiences.  To do so, please visit https://aka.ms/codespaces-signup to get on the list!

Thank you for reading this far and on behalf of the team bringing you .NET Core development on Codespaces, thank you!

The post Using GitHub Codespaces with .NET Core appeared first on .NET Blog.

source https://devblogs.microsoft.com/dotnet/using-github-codespaces-with-net-core/

Board Game, Lists and More - Python Basics with Sam

Curriculum for the course Board Game, Lists and More - Python Basics with Sam

Learn the basics of Python live from Sam Focht every Tuesday. This is part of a series that will cover the entire Python Programming language. Check out Sam's YouTube channel: https://www.youtube.com/python_basics Python Basics with Sam playlist: https://www.youtube.com/playlist?list=PLWKjhJtqVAbkmRvnFmOd4KhDdlK1oIq23 -- Learn to code for free and get a developer job: https://www.freecodecamp.org Read hundreds of articles on programming: https://freecodecamp.org/news And subscribe for new videos on technology every day: https://youtube.com/subscription_center?add_user=freecodecamp

Watch Online Full Course: Board Game, Lists and More - Python Basics with Sam

Click Here to watch on Youtube: Board Game, Lists and More - Python Basics with Sam

This video is first published on youtube via freecodecamp. If Video does not appear here, you can watch this on Youtube always.

Udemy Board Game, Lists and More - Python Basics with Sam courses free download, Plurasight Board Game, Lists and More - Python Basics with Sam courses free download, Linda Board Game, Lists and More - Python Basics with Sam courses free download, Coursera Board Game, Lists and More - Python Basics with Sam course download free, Brad Hussey udemy course free, free programming full course download, full course with project files, Download full project free, College major project download, CS major project idea, EC major project idea, clone projects download free

Flutter Tutorial - Building a Production App From Scratch

Curriculum for the course Flutter Tutorial - Building a Production App From Scratch

Learn how to build well planned and fully tested Flutter apps from scratch. This will guide you through planning what should go into the app, how to stay organized, all the way to fully testing your application. ✏️ Course by Tadas Petra. Check out his channel: https://www.youtube.com/channel/UCNaJHBXsvbfkItVMNmzmTPQ 💻 Link to Code: https://github.com/tadaspetra/todoapp 💻 Link to Widget Test Code: https://github.com/tadaspetra/flutter_basics/tree/master/017_unit_testing ⭐️ Course Contents ⭐️ ⌨️ (00:00) Introduction ⌨️ (00:48) Planning ⌨️ (04:39) Before you start ⌨️ (07:42) Building the App ⌨️ (19:38) Unit Testing ⌨️ (37:15) Widget Testing ⌨️ (41:51) Integration Testing ⌨️ (51:07) Maintainability -- Learn to code for free and get a developer job: https://www.freecodecamp.org Read hundreds of articles on programming: https://freecodecamp.org/news And subscribe for new videos on technology every day: https://youtube.com/subscription_center?add_user=freecodecamp

Watch Online Full Course: Flutter Tutorial - Building a Production App From Scratch

Click Here to watch on Youtube: Flutter Tutorial - Building a Production App From Scratch

This video is first published on youtube via freecodecamp. If Video does not appear here, you can watch this on Youtube always.

Udemy Flutter Tutorial - Building a Production App From Scratch courses free download, Plurasight Flutter Tutorial - Building a Production App From Scratch courses free download, Linda Flutter Tutorial - Building a Production App From Scratch courses free download, Coursera Flutter Tutorial - Building a Production App From Scratch course download free, Brad Hussey udemy course free, free programming full course download, full course with project files, Download full project free, College major project download, CS major project idea, EC major project idea, clone projects download free

UI Design Tutorial - Website From Wireframe

Curriculum for the course UI Design Tutorial - Website From Wireframe

Planning out a website before building it is same as saying measure twice, cut once. Prototyping is a way to do exactly this. When we design our websites, we progress from wireframing, prototyping, and finally, a full design. In this tutorial you will learn what Prototyping actually means and what it looks like. You will see the full process of taking an early prototype and wireframe and creating a website. 🎥 Video from Adrian Twarog. Check out his YouTube channel: https://www.youtube.com/channel/UCvM5YYWwfLwpcQgbRr68JLQ 🔗 Learn how to create a wireframe in the first video in this series: https://youtu.be/pN92rnO_n5U -- Learn to code for free and get a developer job: https://www.freecodecamp.org Read hundreds of articles on programming: https://freecodecamp.org/news And subscribe for new videos on technology every day: https://youtube.com/subscription_center?add_user=freecodecamp

Watch Online Full Course: UI Design Tutorial - Website From Wireframe

Click Here to watch on Youtube: UI Design Tutorial - Website From Wireframe

This video is first published on youtube via freecodecamp. If Video does not appear here, you can watch this on Youtube always.

Udemy UI Design Tutorial - Website From Wireframe courses free download, Plurasight UI Design Tutorial - Website From Wireframe courses free download, Linda UI Design Tutorial - Website From Wireframe courses free download, Coursera UI Design Tutorial - Website From Wireframe course download free, Brad Hussey udemy course free, free programming full course download, full course with project files, Download full project free, College major project download, CS major project idea, EC major project idea, clone projects download free

Data Analysis with Python: Part 6 of 6 - Exploratory Data Analysis - A Case Study [Live Course]

Curriculum for the course Data Analysis with Python: Part 6 of 6 - Exploratory Data Analysis - A Case Study [Live Course]

“Data Analysis with Python: Zero to Pandas” is a practical, beginner-friendly and coding-focused introduction to data analysis covering the basics of Python, Numpy, Pandas, data visualization and exploratory data analysis. You can learn more and register for a Certificate of Accomplishment at http://zerotopandas.com. ⭐️ Resources ⭐️ 🔗 Exploratory Data Analysis notebook: https://jovian.ml/aakashns/python-eda-stackoverflow-survey 🔗 EDA Course project starter notebook: https://jovian.ml/aakashns/zerotopandas-course-project-starter 🔗 Lecture forum discussion: https://jovian.ml/forum/t/lecture-6-exploratory-data-analysis-a-case-study/12077 🔗 Course project discussion: https://jovian.ml/forum/t/course-project-on-exploratory-data-analysis-discuss-and-share-your-work/11684/134 ⭐️ Topics covered ⭐️ ⌨️ Exploratory Data Analysis using Python - A Case Study ⌨️ Course project overview & guidelines ⌨️ Review of topics covered in the course ⌨️ What to do after the course 🎥 Watch the entire series here: https://www.youtube.com/playlist?list=PLWKjhJtqVAblvI1i46ScbKV2jH1gdL7VQ ✏️This course is taught by Aakash N S, cofounder & CEO of Jovian.ml - a platform for sharing, showcasing and collaborating on data science projects online 🔗 YouTube: https://youtube.com/jovianml 🔗 Twitter: https://twitter.com/jovianml 🔗 LinkedIn: https://linkedin.com/company/jovianml -- Learn to code for free and get a developer job: https://www.freecodecamp.org Read hundreds of articles on programming: https://freecodecamp.org/news And subscribe for new videos on technology every day: https://youtube.com/subscription_center?add_user=freecodecamp

Watch Online Full Course: Data Analysis with Python: Part 6 of 6 - Exploratory Data Analysis - A Case Study [Live Course]

Click Here to watch on Youtube: Data Analysis with Python: Part 6 of 6 - Exploratory Data Analysis - A Case Study [Live Course]

This video is first published on youtube via freecodecamp. If Video does not appear here, you can watch this on Youtube always.

Udemy Data Analysis with Python: Part 6 of 6 - Exploratory Data Analysis - A Case Study [Live Course] courses free download, Plurasight Data Analysis with Python: Part 6 of 6 - Exploratory Data Analysis - A Case Study [Live Course] courses free download, Linda Data Analysis with Python: Part 6 of 6 - Exploratory Data Analysis - A Case Study [Live Course] courses free download, Coursera Data Analysis with Python: Part 6 of 6 - Exploratory Data Analysis - A Case Study [Live Course] course download free, Brad Hussey udemy course free, free programming full course download, full course with project files, Download full project free, College major project download, CS major project idea, EC major project idea, clone projects download free

Debug Your .NET Core Apps in WSL 2 with Visual Studio

Are you a .NET Core developer who loves working in Windows and Visual Studio, but needs to test your app in Linux? Are you a cross-platform developer that needs an easy way to test more of your target environments? Have you already discovered the benefits of WSL 2, but need a way to integrate it into your inner loop? Have I got an extension for you! The .NET Core Debugging with WSL 2 – Preview extension gives you the ability to run and debug your .NET Core apps in WSL 2 without leaving Visual Studio.

When would I want to debug in WSL 2?

For a Windows .NET user targeting Linux, WSL 2 lives in a sweet spot between production realism and productivity. In Visual Studio you can already debug in a remote Linux environment using the Remote Debugger, or with containers using the Container Tools. When production realism is your main concern, you should use one of those. When an easy and fast inner-loop is more important, WSL 2 is a great option.

You don’t have to choose just one! You can have a launch profile for Docker and WSL 2 in the same project and pick whichever is appropriate for a particular run. And once your app is deployed, you can always use the Remote Debugger to attach to it if there is an issue.

Getting Started with .NET Core Debugging with WSL 2 – Preview

Before using the extension, be sure to install WSL 2 and the distribution of your choice. After you have installed the extension, when you open an ASP.NET Core web app or .NET Core console app in Visual Studio, you’ll see a new Launch Profile named WSL 2:

Selecting this profile will add it to your launchSettings.json, and will look something like:

"WSL 2": {
    "commandName": "WSL2",
    "launchBrowser": true,
    "launchUrl": "https://localhost:5001",
    "environmentVariables": {
        "ASPNETCORE_URLS": "https://localhost:5001;http://localhost:5000",
        "ASPNETCORE_ENVIRONMENT": "Development"
    },
    "distributionName": ""
}

Once the new profile is selected, the extension checks that your WSL 2 distribution is configured to run .NET Core apps, and helps you install any missing dependencies. Once all the dependencies are installed, you are ready to debug in WSL 2. Simply start Debugging as normal, and your app will now be running in your default WSL 2 distribution. An easy way to verify that you are running in Linux is to check the value of Environment.OSVersion.

Note: Only Ubuntu and Debian have been tested and are supported. Other distributions supported by .NET Core should work but require manually installing the .NET Core Runtime and Curl.

Using a specific distribution

By default, the WSL 2 launch profile will use the default distribution as set in wsl.exe. If you want your launch profile to target a specific distribution, regardless of that default, you can modify your launch profile. For example, if you are debugging a web app and want to test it on Ubuntu 20.04, your launch profile would look like:

"WSL 2": {
    "commandName": "WSL2",
    "launchBrowser": true,
    "launchUrl": "https://localhost:5001",
    "environmentVariables": {
        "ASPNETCORE_URLS": "https://localhost:5001;http://localhost:5000",
        "ASPNETCORE_ENVIRONMENT": "Development"
    },
    "distributionName": "Ubuntu-20.04"
}

Targeting multiple distributions

Going one step further, if you are working on an application that needs to run in multiple distributions and you want a quick way to test on each of them, you can have multiple launch profiles. For instance, if you need to test your console app on Debian, Ubuntu 18.04, and Ubuntu 20.04, you could use the following launch profiles:

"WSL 2 : Debian": {
    "commandName": "WSL2",
    "distributionName": "Debian"
},
"WSL 2 : Ubuntu 18.04": {
    "commandName": "WSL2",
    "distributionName": "Ubuntu-18.04"
},
"WSL 2 : Ubuntu 20.04": {
    "commandName": "WSL2",
    "distributionName": "Ubuntu-20.04"
}

With these launch profiles, you can easily switch back and forth between your target distributions, all without leaving the comfort of Visual Studio:

Give it a try today!

So, if you love working in Visual Studio, but need to test your app in Linux, go to the Visual Studio Marketplace to install the extension today. Please use the marketplace to ask any questions and give us your feedback to let us know how useful this extension is.

The post Debug Your .NET Core Apps in WSL 2 with Visual Studio appeared first on .NET Blog.

source https://devblogs.microsoft.com/dotnet/debug-your-net-core-apps-in-wsl-2-with-visual-studio/

Computer Networking Course - Network Engineering

Curriculum for the course Computer Networking Course - Network Engineering

This full college-level computer networking course will prepare you to configure, manage, and troubleshoot computer networks. It will also help you prepare for CompTIA's Network+ exam. This course was developed by Brian Ferrill, an instructor at Edmonds Community College. ⭐️ Course Contents ⭐️ ⌨️ (0:00:00) Intro to Network Devices (part 1) ⌨️ (0:07:24) Intro to Network Devices (part 2) ⌨️ (0:15:12) Networking Services and Applications (part 1) ⌨️ (0:22:49) Networking Services and Applications (part 2) ⌨️ (0:28:17) DHCP in the Network ⌨️ (0:38:03) Introduction to the DNS Service ⌨️ (0:46:01) Introducing Network Address Translation ⌨️ (0:52:52) WAN Technologies (part 1) ⌨️ (1:03:02) WAN Technologies (part 2) ⌨️ (1:09:32) WAN Technologies (part 3) ⌨️ (1:17:20) WAN Technologies (part 4) ⌨️ (1:22:32) Network Cabling (part 1) ⌨️ (1:31:24) Network Cabling (part 2) ⌨️ (1:38:15) Network Cabling (part 3) ⌨️ (1:43:28) Network Topologies ⌨️ (1:50:29) Network Infrastructure Implementations ⌨️ (1:56:26) Introduction to IPv4 (part 1) ⌨️ (2:02:42) Introduction to IPv4 (part 2) ⌨️ (2:15:58) Introduction to IPv6 ⌨️ (2:26:10) Special IP Networking Concepts ⌨️ (2:34:06) Introduction to Routing Concepts (part 1) ⌨️ (2:40:00) Introduction to Routing Concepts (part 2) ⌨️ (2:49:29) Introduction to Routing Protocols ⌨️ (2:59:01) Basic Elements of Unified Communications ⌨️ (3:04:27) Virtualization Technologies ⌨️ (3:09:24) Storage Area Networks ⌨️ (3:15:33) Basic Cloud Concepts ⌨️ (3:21:43) Implementing a Basic Network ⌨️ (3:31:02) Analyzing Monitoring Reports ⌨️ (3:40:03) Network Monitoring (part 1) ⌨️ (3:48:14) Network Monitoring (part 2) ⌨️ (3:55:10) Supporting Configuration Management (part 1) ⌨️ (4:01:52) Supporting Configuration Management (part 2) ⌨️ (4:07:19) The Importance of Network Segmentation ⌨️ (4:14:18) Applying Patches and Updates ⌨️ (4:19:52) Configuring Switches (part 1) ⌨️ (4:26:39) Configuring Switches (part 2) ⌨️ (4:36:27) Wireless LAN Infrastructure (part 1) ⌨️ (4:46:42) Wireless LAN Infrastructure (part 2) ⌨️ (4:53:17) Risk and Security Related Concepts ⌨️ (5:00:46) Common Network Vulnerabilities ⌨️ (5:09:49) Common Network Threats (part 1) ⌨️ (5:17:13) Common Network Threats (part 2) ⌨️ (5:26:33) Network Hardening Techniques (part 1) ⌨️ (5:36:00) Network Hardening Techniques (part 2) ⌨️ (5:44:40) Network Hardening Techniques (part 3) ⌨️ (5:50:58) Physical Network Security Control ⌨️ (5:57:19) Firewall Basics ⌨️ (6:06:53) Network Access Control ⌨️ (6:13:22) Basic Forensic Concepts ⌨️ (6:22:42) Network Troubleshooting Methodology ⌨️ (6:29:18) Troubleshooting Connectivity with Utilities ⌨️ (6:36:32) Troubleshooting Connectivity with Hardware ⌨️ (6:43:39) Troubleshooting Wireless Networks (part 1) ⌨️ (6:50:56) Troubleshooting Wireless Networks (part 2) ⌨️ (6:57:27) Troubleshooting Copper Wire Networks (part 1) ⌨️ (7:03:49) Troubleshooting Copper Wire Networks (part 2) ⌨️ (7:09:19) Troubleshooting Fiber Cable Networks ⌨️ (7:14:43) Network Troubleshooting Common Network Issues ⌨️ (7:24:40) Common Network Security Issues ⌨️ (7:35:12) Common WAN Components and Issues ⌨️ (7:43:33) The OSI Networking Reference Model ⌨️ (7:51:50) The Transport Layer Plus ICMP ⌨️ (7:58:35) Basic Network Concepts (part 1) ⌨️ (8:05:33) Basic Network Concepts (part 2) ⌨️ (8:12:29) Basic Network Concepts (part 3) ⌨️ (8:17:42) Introduction to Wireless Network Standards ⌨️ (8:24:26) Introduction to Wired Network Standards ⌨️ (8:32:41) Security Policies and other Documents ⌨️ (8:40:08) Introduction to Safety Practices (part 1) ⌨️ (8:48:34) Introduction to Safety Practices (part 2) ⌨️ (8:54:26) Rack and Power Management ⌨️ (9:00:25) Cable Management ⌨️ (9:05:56) Basics of Change Management ⌨️ (9:12:11) Common Networking Protocols (part 1) ⌨️ (9:18:06) Common Networking Protocols (part 2)

Watch Online Full Course: Computer Networking Course - Network Engineering

Click Here to watch on Youtube: Computer Networking Course - Network Engineering

This video is first published on youtube via freecodecamp. If Video does not appear here, you can watch this on Youtube always.

Udemy Computer Networking Course - Network Engineering courses free download, Plurasight Computer Networking Course - Network Engineering courses free download, Linda Computer Networking Course - Network Engineering courses free download, Coursera Computer Networking Course - Network Engineering course download free, Brad Hussey udemy course free, free programming full course download, full course with project files, Download full project free, College major project download, CS major project idea, EC major project idea, clone projects download free

.NET Framework September 2020 Cumulative Update Preview Update

Today, we are releasing the September 2020 Cumulative Update Preview Updates for .NET Framework.

Quality and Reliability

This release contains the following quality and reliability improvements.

ASP.NET

• Disabled resuse of AppPathModifier in ASP.Net control output.
• HttpCookie objects in the ASP.Net request context will be created with configured defaults for cookie flags instead instead of .Net.NET-style primitive defaults to match the behavior of `new HttpCookie(name)`.

CLR¹

• Added a CLR config variable Thread_AssignCpuGroups (1 by default) that can be set to 0 to disable automatic CPU group assignment done by the CLR for new threads created by Thread.Start() and thread pool threads, such that an app may do its own thread-spreading.
• Addressed a rare data corruption that can occur when using new API’s such as Unsafe.ByteOffset which are often used with the new Span types. The corruption could occur when a GC operation is performed while a thread is calling Unsafe.ByteOffset from inside of a loop.
• Addressed an issue regarding timers with very long due times ticking down much sooner than expected when the AppContext switch “Switch.System.Threading.UseNetCoreTimer” is enabled.

SQL

• Addressed a failure that sometimes occured when a user connected to one Azure SQL database, performed an enclave based operation, and then connected to another database under the same server that has the same Attestation URL and performed an enclave operation on the second server.

WCF²

• Addressed an issue with WCF services sometimes failing to start when starting multiple services concurrently.

Windows Forms

• Addressed a regression introduced in .NET Framework 4.8, where Control.AccessibleName, Control.AccessibleRole, and Control.AccessibleDescription properties stopped working for the following controls:Label,GroupBox,ToolStrip,ToolStripItems,StatusStrip,StatusStripItems,PropertyGrid,ProgressBar,ComboBox,MenuStrip,MenuItems,DataGridView.
• Addressed a regression in accessible name for combo box items for data bound combo boxes. .NET Framework 4.8 RTM started using type name instead of the value of the DisplayMember property as an accessible name, this fiximprovement uses the DisplayMember again.

¹ Common Language Runtime (CLR) ² Windows Communication Foundation (WCF)

Getting the Update

The Cumulative Update Preview is available via Windows Update and Microsoft Update Catalog.

Microsoft Update Catalog

You can get the update via the Microsoft Update Catalog. For Windows 10, NET Framework 4.8 updates are available via Windows Update and Microsoft Update Catalog. Updates for other versions of .NET Framework are part of the Windows 10 Monthly Cumulative Update.

**Note**: Customers that rely on Windows Update will automatically receive the .NET Framework version-specific updates. Advanced system administrators can also take use of the below direct Microsoft Update Catalog download links to .NET Framework-specific updates. Before applying these updates, please ensure that you carefully review the .NET Framework version applicability, to ensure that you only install updates on systems where they apply.

The following table is for Windows 10 and Windows Server 2016+ versions.

Product Version	Cumulative Update
Windows 10 1909 and Windows Server, version 1909
.NET Framework 3.5, 4.8	Catalog	4576947
Windows 10 1903 and Windows Server, version 1903
.NET Framework 3.5, 4.8	Catalog	4576947
Windows 10 1809 (October 2018 Update) and Windows Server 2019		4577324
.NET Framework 3.5, 4.7.2	Catalog	4576949
.NET Framework 3.5, 4.8	Catalog	4576946

 

Previous Cumulative Updates

The last few .NET Framework updates are listed below for your convenience:

• .NET Framework September 2020 Security and Quality Rollup Updates
• .NET Framework September 3, 2020 Cumulative Update Preview for Windows 10 2004 and Windows Server, version 2004
• .NET Framework August 2020 Cumulative Update Preview
• .NET Framework August 2020 Security and Quality Rollup Updates

The post .NET Framework September 2020 Cumulative Update Preview Update appeared first on .NET Blog.

source https://devblogs.microsoft.com/dotnet/net-framework-september-2020-cumulative-update-preview-update/