dotnet-foundation / foundation Goto Github PK

When visiting https://dotnetfoundation.org/team, I noticed that the email icon under Miklos Barkoczi's name has mailto: referenced twice. It may be obvious to some, but not to others.

<a href="mailto:mailto:[email protected]">
    <i class="fa fa-envelope" aria-hidden="true"></i>
</a>

should be

<a href="mailto:[email protected]">
    <i class="fa fa-envelope" aria-hidden="true"></i>
</a>

In our Governance section we should define a lifecycle for projects, specifically:

• What states we consider a project to be in
• What those states mean for the people running the project but also people thinking about taking a dependency on it
• Any gates or approval process before a project is allowed to be in a certain state

The best way to think about this is to take some examples.

.NET Core (or the coreclr, corefx & rosyln projects) are very active. They have shipped a V1 and we want to consider them as part of the core platform. The CLA must be enabled for .NET Core repos and the .NET Core teams consult regularly with the Technical Steering Group to help with co-ordination.

MEF v2 is now System.Composition in the corefx project. It is very much alive an active as a technology - but the old MEF v2 project and MEF v1 is essentially shelved or in an archive state. How do we explain that to consumers?

Wix, Orchard & Umbraco are very active, stable projects with many releases under their belts - but equally we want to make sure they have complete autonomy and freedom to work well (provided the projects adhere to our code of conduct).

Projects like LLILC are more on the experimental / incubation side of the house. They are cool, innovative technologies that are actively getting worked on but we wouldn't consider them completely mainstream yet. Definitely something you can use if it fits the bill for what you need, but beware that the project is still in the early stages.

We want to support innovation in .NET - we don't want to limit projects in the .NET Foundation to ones that have already proven themselves broadly useful. However we also want to make sure people know what to expect from a project, but also what we should do if we declare that a project is no longer being actively worked on. Their should also be a process in place is someone wants to pick up a project that is no-longer active and try to get it going again.

I was thinking we could:

• Agree on a initial list of states that we can define projects to be in
• Flesh out what each of those states mean
• Define how a projects gets to declare it is in one of the states
• Define the process to move to a different state
• Write all this up in a file in the Guidance folder and submit it as a PR for review
• Start rolling it out across the .NET Foundation projects.

Thoughts?

Hello!

I've found that Microsoft.Cci is still active in development as per the NuGet feed:
https://dotnet.myget.org/feed/dotnet-core/package/nuget/Microsoft.Cci

Unfortunately, I wasn't able to find the repository where the sources are maintained and would very much appricate information to this regard.

Many thanks, Michael

Roslyn is one of the more popular projects. It would be nice to show us on the main page and in the projects page.

For example: mono/libgdiplus#109

I have already signed the CLI. On the dotnet/corefx etc. projects, I don't get the extra message:

@hughbe,
Thanks for having already signed the Contribution License Agreement. Your agreement was validated by .NET Foundation. We will now review your pull request.
Thanks,
.NET Foundation Pull Request Bot

Just a small gripe, as I get an email each time I do this. I've seen this in Mono and Xunit.

/cc @karelz I know this is unrelated to corefx but maybe you know the right person/repo to route this to :D

This link:

http://ivantomic.com/projects/ospnc/

404's

See issue:

https://github.com/LogIN-/ospnc/issues/21

https://github.com/PomeloFoundation/Pomelo.EntityFrameworkCore.MySql

I want to join .net foundation.

With reference to PR #158 I'm requesting to add Akka.NET to the DNF project listings.

https://fbcdn-profile-a.akamaihd.net/hprofile-ak-xap1/v/t1.0-1/p160x160/971596_519168901464439_566592989_n.png?oh=ce61e5b4cbd60c0d99c4164cbb05a434&oe=54F091C9&__gda__=1424472439_c9f76213a915bc2af88246f464f29e8b results in a 404.
https://github.com/dotnet/foundation/blob/c7e513139f593ad95237e864e4d2fdf9181ebafc/projects/projects.json#L149-L151

Target organizations: aspnet, dotnet

Inspired by many runtimes, build systems, package managers, and as a principle; please prefer using #!/bin/sh shebang instead of #!/usr/bin/env bash in Unix shell scripts; as sh is a standard POSIX command language interpreter (http://pubs.opengroup.org/onlinepubs/9699919799/utilities/sh.html) in particular Bourne shell which is the lowest common denominator, while bash is not available OOTB in many default shells shipped with Unix-like operating systems including *BSD.

For example, at the moment, bash is an undesired dependency on FreeBSD to build aspnet/dnx, dotnet/coreclr etc. The default (auxiliary) shell for FreeBSD is tcsh.

One good example, IMO, is node.js world where majority of shell scripts retain Bourne shell compatibility. To wit, install some npm package say npm itself: npm install npm in a tmp directory (directory-level installation, with -g switch addition, it would become system/global level) and find out the Bourne compatible shortcut script: cat ./node_modules/.bin/npm.

If there is an agreement on this proposal, we can add a checklist here like dotnet/aspnetcore#695 to track the progress for all the repositories which require conversion of shell script files, which are used for build system in dist. After that, lets do not use any bash specific script in future. :)

This will take some major effort, as there are many files to convert and the fact that scripting in Bourne sh is bit more rawer than bash etc.

/cc: @akoeplinger, @davidfowl, @dougbu, @jaredpar, @mmitche, @nguerrera, @NTaylorMullen, @sokket

It's probably safe to assume that community is now understood to be the most vital asset of a strong ecosystem. I've been stoked to see the growth on that front in the .net universe. The smallest, most tangible unit of measure in my opinion is the package. You can generally speaking gauge the health of a community by the number of packages it has - even if many of those packages are noise.

For .net, this has existed prior to core, but embracing open source has taken off any limits that might have once existed.

Praises aside however, I think there might be a subtle and important void in the tooling and guidance. This is something I've observed as I've been trying to automate delivery of a .net package I'm working on.
The current project system flux might have some minor impact on things, but I do believe that even after the dust has settled, some people are going to be frustrated by the process of publishing packages. Even more specifically: As it pertains to handling the objective of package version.

What's nice is that I recently got a chance to experience how helpful it is when this kind of guidance is offered after getting a typescript project I've authored prepared as an npm package.
The last challenge I faced was specifically to do with establishing a convention for versioning my releases, tagging a release in github and actually getting the bits to npm. While researching the topic, I discovered that someone had already recognized this snag and created a very simple yet crazy-effective tool to get past this hurdle!

So, be it resolved that packages are important and making package publishing easy is equally as important: I think it would be just awesome if one or more of the various dotnet teams got together offered some kind of formal tooling around package publishing. Much the same way that semantic-release has done for npm.

On the page http://www.microsoft.com/net/learn/get-started/linux dropdown "Linux Distribution" has no effect on the installation instruction next to him (they are always displayed for RedHat).

@richlander can you verify the links on this page? They look wrong.

Consider changing link text from links to names, like this:

ASP.NET vNext

Consider using the link above for ASP.NET vNext instead of the KRuntime one. There are lots of vNext repos. Home is the place to start.

Consider alpha-ordering the projects.

Not sure where to open this issue.
I'm experiencing crashes since I migrated to .net core 2.0 while running my site.
The following is the exception and stack trace:

An unhandled exception of type 'System.ArgumentException' occurred in System.Private.CoreLib.dll
The path is not of a legal form.

System.Private.CoreLib.dll!System.IO.Path.GetFullPath(string path)	Unknown	No symbols loaded.
 	Microsoft.Extensions.FileSystemGlobbing.dll!Microsoft.Extensions.FileSystemGlobbing.InMemoryDirectoryInfo.InMemoryDirectoryInfo(string rootDir, System.Collections.Generic.IEnumerable<string> files, bool normalized)	Unknown	No symbols loaded.
 	Microsoft.Extensions.FileSystemGlobbing.dll!Microsoft.Extensions.FileSystemGlobbing.MatcherExtensions.Match(Microsoft.Extensions.FileSystemGlobbing.Matcher matcher, string rootDir, System.Collections.Generic.IEnumerable<string> files)	Unknown	No symbols loaded.
 	Microsoft.Extensions.FileSystemGlobbing.dll!Microsoft.Extensions.FileSystemGlobbing.MatcherExtensions.Match(Microsoft.Extensions.FileSystemGlobbing.Matcher matcher, string file)	Unknown	No symbols loaded.
 	Microsoft.Extensions.FileProviders.Physical.dll!Microsoft.Extensions.FileProviders.Physical.PhysicalFilesWatcher.ReportChangeForMatchedEntries(string path)	Unknown	No symbols loaded.
 	Microsoft.Extensions.FileProviders.Physical.dll!Microsoft.Extensions.FileProviders.Physical.PhysicalFilesWatcher.OnFileSystemEntryChange(string fullPath)	Unknown	No symbols loaded.
 	Microsoft.Extensions.FileProviders.Physical.dll!Microsoft.Extensions.FileProviders.Physical.PhysicalFilesWatcher.OnRenamed(object sender, System.IO.RenamedEventArgs e)	Unknown	No symbols loaded.
 	System.IO.FileSystem.Watcher.dll!System.IO.FileSystemWatcher.NotifyRenameEventArgs(System.IO.WatcherChangeTypes action, string name, string oldName)	Unknown	No symbols loaded.
 	System.IO.FileSystem.Watcher.dll!System.IO.FileSystemWatcher.ParseEventBufferAndNotifyForEach(byte[] buffer)	Unknown	No symbols loaded.
 	System.IO.FileSystem.Watcher.dll!System.IO.FileSystemWatcher.ReadDirectoryChangesCallback(uint errorCode, uint numBytes, System.Threading.NativeOverlapped* overlappedPointer)	Unknown	No symbols loaded.
 	System.Private.CoreLib.dll!System.Threading._IOCompletionCallback.PerformIOCompletionCallback(uint errorCode, uint numBytes, System.Threading.NativeOverlapped* pOVERLAP)	Unknown	No symbols loaded.

I'm not sure how to fix this. I can reproduce it although it's not easy since I think it has to do with timing...

The README has link under the "Cameron Taggart" section pointing to https://github.com/ctaggart/SourceLink but the project now seems to live under the "dotnet" org in https://github.com/dotnet/sourcelink/ which suggests the link should be changed to that, and moved under the "Microsoft" section.

About still mentions CodePlex which is now in archive mode.

Is this something that I can PR?

Not sure if it’s appropriate to report this here, but when browsing to the dotnet foundation org website, I get the following error.

HTTP Error 500.30 - ANCM In-Process Start Failure

Common solutions to this issue:
The application failed to start
The application started but then stopped
The application started but threw an exception during startup
Troubleshooting steps:
Check the system event log for error messages
Enable logging the application process' stdout messages
Attach a debugger to the application process and inspect
For more information visit: https://go.microsoft.com/fwlink/?LinkID=2028265

I'd be interested in which part of the project submission guidelines is optional and which are deal breaker requirements.

• Is the Role Matrix laid out an absolute or (as can be read between the lines) just a preset, which may be subject to individual projects needs?
• Is it a strong requirement that the project uses the contributor covenant CoC?

The CSP policy on https://dotnetfoundation.org/reactiveui is preventing embedding images. I'd prefer to not to adjust CSP policy to add the reactiveui.net and instead have some way to pull-request images into this repository.

It appears that HTTPS works just fine: https://www.dotnetfoundation.org/

But the links at these places use HTTP:

1. The link in the header of https://github.com/dotnet/home
2. The link in the header of https://github.com/dotnet
3. Some links in https://github.com/dotnet/home/blob/master/README.md (both to .NET Foundation, and a GitHub link to another project)

These links should all change to HTTPS.

Can/should this image be used?

https://github.com/dotnet/foundation/blob/c7e513139f593ad95237e864e4d2fdf9181ebafc/projects/projects.json#L155-L157

1. General Information

Project Name:
Marten

License:
MIT

Contributor (Company, Organization or individual name(s)):
Jeremy D. Miller, Babu Annamalai, Oskar Dudycz, Joona-Pekka Kokko

Existing OSS Project? (Yes/No):
Yes

Source Code URL:
https://github.com/JasperFx/marten

Project Homepage URL (if different):
https://martendb.io

Project Transfer Signatories:
Full legal name and email address required of the individual(s) with the authority to transfer or contribute the project to the .NET Foundation. Note that if you'd prefer not to include this in the public application, it can be submitted via e-mail to [email protected] (referencing this issue number).

Jeremy D. Miller [email protected]
Babu Annamalai [email protected]
Oskar Dudycz [email protected]
Joona-Pekka Kokko [email protected]

2. Description

Please provide a brief statement about your project in terms that are understandable to the target consumer of the library or project, i.e. an elevator pitch for the project:

Marten gives developers a multi-paradigm framework for modelling, storing and querying data on PostgreSQL. Making use of the battle hardened database engine, Marten transparently exposes the JSON(B) capabilities of PostgreSQL for managing objects and events alike, requiring no ceremony to enable friction-less development. Marten is your object (document) and event store, with bells and whistles attached, be it CRUD, Event Sourcing or anything between.

Please provide a 1 sentence (<140 character) summary of your to help users when searching the .NET Foundation projects
Polyglot Persistence providing object (document) and event store Powered by .NET and PostgreSQL

3. Project Governance

Please complete this section about who will be maintaining the open source project and how it will run.
Project Lead:
(Who is the primary contact point for the community and the .NET Foundation when discussing governance of the project.)

Name: Jeremy D. Miller
Email: [email protected]
GitHub Profile URL: https://github.com/jeremydmiller

Committers:

Which individuals have commit / write access to the repository, what is their GitHub ID and who is their employer (if contributions are on behalf of an employer)

Jeremy D. Miller https://github.com/jeremydmiller

Babu Annamalai https://github.com/mysticmind

Oskar Dudycz https://github.com/oskardudycz

Joona-Pekka Kokko https://github.com/jokokko

Governance Model:

Please describe how new code changes are proposed to the project, how those changes are reviewed and how a decision is made to accept proposed changes. Also describe the process for identifying and appointing new committers.

Changes are proposed via GH issues. All issues are reviewed and labelled with the proper type and scope. Issues that have the estimated timeline are assigned to a proper milestone. Milestones reflect the package version based on the semantic versioning.
Plans for the new releases are discussed publicly in the issues (see eg. JasperFx/marten#1307 or JasperFx/marten#1391).
Quick surveys, questions, clarifications and in general contact with community is done in dedicated Gitter channel https://gitter.im/JasperFx/marten.
Normally 2 approves from maintainers are needed to merge the Pull Request.
New committers were appointed once by Jeremy based on the number and quality of commits, activity and helping the community. See more: https://jeremydmiller.com/2018/09/27/marten-3-0-is-released-and-introducing-the-new-core-team/

CLA

If already an OSS project, was a Contribution License Agreement in place for contributions accepted? How does the project check who has signed one?

No.

CLA Notification Alias
Provide an email address that will receive CLA related notifications from the .NET Foundation CLA automation

Project Transfer Type

Projects may join the .NET Foundation in one of two ways and you should chat with your .NET Foundation contact to discuss the best mechanism for your project. You can either a) assign the copyright of the project's source code to the .NET Foundation or b) contribute the project source code to the .NET Foundation under an open source license. Assignment is the preferred approach, but licensing a project to the Foundation may be more appropriate for longer running open source projects that have not previously had a contribution license agreement and have accepted contributions from many different sources.
a) Assignment
b) Contribution

Contribution.

4. Repository Layout

_The .NET Foundation host guidance for new projects and details on recommended structure here:
https://github.com/dotnet/home/tree/master/guidance

Note that the open source repository should be the master where changes are made by the core development team using the same PR process that is used for non-committer contributions.

Please define below any changes you would want to make to your repositories as part of the process of joining the .NET Foundation_

I don’t think any repository changes are required as part of this process.

5. PR Plan

Please summarize the public relations plan for the announcement when joining the foundation (and releasing as open source if appropriate). What is the main story we wish to promote, through what channels, what issues should we be aware of? For significant news events then please also work with your .NET Foundation contact to ensure a full PR plan is developed.

Currently we'll promote that through blog post, twitter announcement using twitter handle @marten_lib & updated website https://martendb.io. We also want to provide the newsletter and maybe more video tutorials. Contributors also speak about the Event Sourcing with .NET Core and Marten on the local meetups. We also plan to get some sponsorship plan (not clear as yet - JasperFx/marten#1393).

6. Infrastructure Requirements

Please describe any infrastructure requirements for the project. For example, how will build servers be operated? Any web hosting or service hosting requirements? Do we need to set up SSL certificates or provide Authenticode Code Signing arrangement for releases?

Currently, we're using the Azure Pipelines and AppVeyor OSS plans and we're happy with that process. We are building our documentation using Storyteller (https://storyteller.github.io/documentation/docs/) hosted on GitHub pages and Netlify so we also don't need to change it as for now. We might need in the future SSL certificates or Authentication Code Signing.

7. Additional Notes

Please provide any additional information required or use this area for notes during the on boarding process. If this open source project has similarities with any other projects in this space then please detail them and why this project is different. If there are any potential issues that you feel the project might need help with early on then also state them here and discuss with your .NET Foundation Contact.

Marten is sometimes compared to Entity Framework. But Marten is not an ORM, it should be treated as the .NET Document and Event Store that's just backed with PostgreSQL. Our approach to using the PostgreSQL and its sophisticated JSON(B) features is unique in .NET space. It should be more compared to RavenDB rather than Entity Framework.
We're working on the sustainability of our model (so getting sponsorship) to be able to work on the dedicated time and get more reliability in bigger Enterprise companies. Such help would be more than welcome from .NET Foundation.

Apology for my poor english!

I have change to Java due to the boss's decision . I think dotnet need a big change. In China, more and more dotnet project go to die, but new java project continuously increase!

I suggest:key F12 go to source code of dotnetcore rather then metadata(e.g. .dll.source.zip *.exe.source.zip), maybe there is already done,but i don't know.

thanks!

https://raw.githubusercontent.com/paulcbetts/mvvmlight/master/Installer/InstallItems/html/MVVM_BlackText_190x147.png results in a 404.
https://github.com/dotnet/foundation/blob/c7e513139f593ad95237e864e4d2fdf9181ebafc/projects/projects.json#L137-L139

The checklist contains a link to http://ivantomic.com/projects/ospnc/ which is unreachable.

Realistically will csharp ever reach the #1 spot of programming languages? Is it even a goal?
I have this nagging feeling that microsoft doesn't even want it to be the #1
Are you okay with #2 or even #5?
I don't work every day as hard as I possibly can just to wake up and feel like a chump who uses a second class ranked language.

These are the facts:
http://www.tiobe.com/tiobe-index/

c# is not just a community, it's a family and as such we should stick together and make it greater than ever before.
What I want to hear from Microsoft is a fight plan on how we are going to get to the top spot, what needs to be done and what we as a community can do to help to get there.
I also want an analysis from the managers and a statement, possibly an apology actually as to why exactly we are still not the number 1.

The CSP policy on https://dotnetfoundation.org/reactiveui is preventing embedding the ReactiveUI introduction video.

https://developers.google.com/web/fundamentals/security/csp/

child-src lists the URLs for workers and embedded frame contents. 
For example: child-src https://youtube.com would enable embedding videos
from YouTube but not from other origins. Use this in place of the
deprecated frame-src directive.

The Team somewhen Mention, that fixes should be installed automatically, if .NET Core is on a Windows Server.
This seems not to work. What are the prerequisits for this to be working?

https://github.com/dnfclas

Expected

Actual

Always capitalized, never .Net or dot NET.

.NET Glossary

Microsoft Style Guide

Just read in https://github.com/dotnet/cli/issues/2676#issuecomment-214938537 that dotnet pack is going to be deprecated.

Is this still the case, or is that now outdated information?

At the moment, the definition of which projects should consider applying to join the .NET Foundation is a little bit hazy and it's a question I often get asked about. I was thinking of creating a PR to spell this out more but before I did, just wanted to check people are ok with that?

As we've been building the .NET Foundation, the following rough guidelines have emerged based on the feedback from the Advisory Council, the Board of Directors and more recently also the Technical Steering Group on new project applications that have been put forward:

• The project must be licensed under a permissive, OSI recognised open source license (e.g. MIT, Apache 2.0, BSD etc)
• The project should define a process for accepting contributions and also provide information about how contributors become maintainers to support a sustainable level of ongoing contribution and activity
• The project community must be willing to adhere to the .NET Foundation Code of Conduct
• The project should be willing for contributors to sign the .NET Foundation Contribution License Agreement using the automated tooling that we help them set up
• The project should be of general use to the .NET community. The Advisory Council and Technical Steering Group help the Board of Directors in determining this.

Any additional thoughts before I turn into a PR?

Hi,

I don't know exactly in which repo I should post this issue, I hope you can direct it to the right place.
I use VS 2015 Update 1 RC and if I create a new Web -> Class library project with .NET Framework 4.6 my reference section shows ".NET Framework 4.5.1" and the new ".NET Platform 5.4".
But why ".NET Framework 4.5.1", this is in no way clear and confusing I think.
I don't know the reason but even if it is because .NET 4.6 is backward compatible to .NET 4.5.1, shown should anyway the Framework I choose on "New project".

Kind regards

https://brandfolder.com/pivotal-assets/attachments/ohxttd-7yxa60-clvf50/pivotal-assets-pivotal-genericfile.png redirects to a sign in page
https://github.com/dotnet/foundation/blob/c7e513139f593ad95237e864e4d2fdf9181ebafc/projects/projects.json#L128-L130

We are getting a fairly steady flow of spam that could be cut down on by adding a good captcha to the page.