Giter Club home page Giter Club logo

housekeeping's People

Contributors

mauroservienti avatar

Watchers

 avatar  avatar  avatar  avatar

Forkers

waffle-iron

housekeeping's Issues

Separate Radical into multiple repositories

The issue we are currently facing is that having all the projects, that ends up in different NuGet packages, complicates the release of a single package/project.
In light of having a build server what I expect to be able to do is via GitFlow:

  • define a feature;
  • create a branch for the above feature;
  • implement;
  • finish the feature tagging the feature with the expected version, such as 1.3.0.1-Beta;
  • push to the develop:
    • once pushed to the develop the build server kicks in, builds the project, creates the NuGet package and pushes it to MyGet;
  • create via GitFlow a release
  • do the required adjustments where needed;
  • finish the release tagging it with the release number;
  • push to 'master`:
    • once pushed to the master the build server kicks in, builds the project, creates the NuGet package and pushes it to NuGet;

Not only, having multiple repositories force us to think much more to features that span multiple projects. Only a good thing.

Improve GitVersion config

  • Change the develop GitVersion configuration to prevent increment of merged version
    prevent-increment-of-merged-branch-version: true
    • Radical
    • Radical.Windows
    • Radical.Design
    • Radical.Windows.Presentation
    • Radical.Windows.Presentation.CastleWindsor
    • Radical.Windows.Presentation.Autofac
    • Radical.Windows.Presentation.Unity2
    • Radical.Windows.Presentation.Unity3
  • Move develop branches to alpha instead of beta
    • Radical
    • Radical.Windows
    • Radical.Design
    • Radical.Windows.Presentation
    • Radical.Windows.Presentation.CastleWindsor
    • Radical.Windows.Presentation.Autofac
    • Radical.Windows.Presentation.Unity2
    • Radical.Windows.Presentation.Unity3

Related to #35

Commitment and maintainer group size

At the time of this writing we have 12 pending PRs among which some quite old.

Obviously due to the fact that Radical is not our main focus, unfortunately we need to work as well, it is sometimes hard to commit, this is obviously complicated by the fact that the maintainer group is super small (@micdenny and I) and the we cannot merge our own PRs rule is causing some pain.

I actually see two possible approaches:

  • Find and introduce at least one new maintainer. Super complex, reviewing other PRs requires great skills and requires deep knowledge of the framework itself. We can, however we need to take into account that it might take a lot of time
  • put in place some W.I.P e.g. not more than 4 items in progress over the entire toolkit and at the same time try to enforce some commitment e.g. a PR should be reviewed within 3 days (whatever number we come up with is good)

@micdenny comments? thoughts?

Code Analyzers

Create a set of Code Analyzers, based on Roslyn, to guide developers to gain the best from Radical

//cc @micdenny

Unlist obsoleted/unsupported Nuget packages

  • Radical.Directives.AngularJS
  • Jason.Client.AngularJS
  • Radical.Windows.Presentation.Conventions.Settings
  • Radical.Windows.Presentation.Puzzle
  • Radical.Windows.Presentation.Puzzle.WinRT
  • Radical.Windows.WinRT
  • Radical.WinRT
  • Radical.Win32
  • Radical.ServiceModel
  • Radical.Extensions.EmitMapper
  • Radical.Extensions.CastleWindsor
  • Radical.Extensions.Aspects

RadicalFx new logo

  • create the new log
  • All NuGet packages
    • Radical
    • Radical.Windows
    • Radical.Design
    • Radical.Windows.Presentation
    • Radical.Windows.Presentation.CastleWindsor
    • Radical.Windows.Presentation.Autofac
    • Radical.Windows.Presentation.Unity2
    • Radical.Windows.Presentation.Unity3
  • Website
  • All Readme files
    • Radical
    • Radical.Windows
    • Radical.Design
    • Radical.Windows.Presentation
    • Radical.Windows.Presentation.CastleWindsor
    • Radical.Windows.Presentation.Autofac
    • Radical.Windows.Presentation.Unity2
    • Radical.Windows.Presentation.Unity3
  • GitHub team/organization
  • VSIX Templates
  • All Radical.CQRS packages
    • Radical.CQRS.EntityFramework
    • Radical.CQRS.Server
    • Radical.CQRS.Handlers
    • Radical.CQRS.Client
    • Radical.CQRS
    • Radical.CQRS.Messages
    • Radical.CQRS.NHibernate (not on Nuget, yet)
  • Radical Universal repo
  • Radical Universal package(s)

logo proposal:

radical_framework_orange_logo

advantages:

  • it is a font :-) the entire logo is a font + a bunch of CSS;
  • the symbol is basically the indian rupee currency symbol but it is also Radical Framework

Align labels across repos

Using housekeeping as the baseline

  • Radical
  • Radical.Windows
  • Radical.Design
  • Radical.Windows.Presentation
  • Radical.Windows.Presentation.CastleWindsor
  • Radical.Windows.Presentation.Autofac
  • Radical.Windows.Presentation.Unity2
  • Radical.Windows.Presentation.Unity3

Verify if ILMerge can cause issues to the end user

the last thing, a little bit out of the scope, is that embedding Radical
dll(s) in the application executable seems not to be possibile (this could
be a nice feature when you want to distribute an application in 1 file),
because some dll are loaded dynamically at runtime searching on physical
path, I had to exclude from embedding this files:
System.Windows.Interactivity.dll,
Radical.Windows.Presentation.CastleWindsor.dll,
Radical.Windows.Presentation.dll
probably I have to investigate deeper this, in that case I'm using
SmartAssembly (by redgate) and I should also try with ILMerge or
ILRepack.

Introduce GitVersion to simplify the release process

Currently, IMO, the release process is a bit too complicated. The user need to manually bump the version number, not expected. Then we need to remember to release in production bumping again the version number in another place on a different branch. Once a thing is merged into develop we have no standard way to keep track that it needs to be released. Other than this we have master and develop that tend to complicate things.

What if:

  • introduce GitVersion
  • skip manually bumping the version
  • when we want to:
    • Release add a tag using a PR or a release-m.m branch
    • Add bug fixes we use a suppport-m.m branch
    • Add an hotfix in production we use a hotfix-m.m branch
  • the build will have the correct versions created by GitVersion automatically

Make the master release process on AppVeyor create a release on GitHub

We have the @radical-bot user that can be used to create a TAG and push is back to the repo, in order to make it work we need to generate a security token for the user and change the AppVeyor config adding the following: https://www.appveyor.com/docs/deployment/github

  • Radical
  • Radical.Windows
  • Radical.Design
  • Radical.Windows.Presentation
  • Radical.Windows.Presentation.CastleWindsor
  • Radical.Windows.Presentation.Autofac
  • Radical.Windows.Presentation.Unity2
  • Radical.Windows.Presentation.Unity3

The changes that need to be done are:

  • add skip_tags: true to the develop and master config so that a tag doesn't trigger a build
  • add the following to the master deploy section:
  - provider: GitHub    
    release: $(GitVersion_NuGetVersion)
    description: 'Release v$(GitVersion_NuGetVersion)'
    auth_token:
      secure: 2ijF4OfPYfIUTunubL/Z04ogADL9sx/gKW1jMRNJnAa1OpHZpSvCKmP0gvNs8C7h
    artifact: /.*\.nupkg/, src\build\Release.zip
    on:
      branch: master

Related to #35

Move develop branches to alpha instead of beta

  • Radical
  • Radical.Windows
  • Radical.Design
  • Radical.Windows.Presentation
  • Radical.Windows.Presentation.CastleWindsor
  • Radical.Windows.Presentation.Autofac
  • Radical.Windows.Presentation.Unity2
  • Radical.Windows.Presentation.Unity3

Related to #35

Fix nuget packages icon

as you can see in some packages there's the icon in some other not:

image

all the radical nuget packages need the new radical icon:

image

How to handle cross-repo documentation?

The entire documentation is in the WiKi repo of the Radical Desktop project.

We can go on adding doco there with no issues even if we reference something that is not there, such as the Universal Apps support, or we can:

  1. spread the documentation across repositories;
  2. create a repo for the documentation only and add everything there using Jekyll + GitHub pages instead of the WiKi

Benefits of "2" are:

  • we can easily create issues for docu;
  • we can close and manage issues and docu with PR;
  • we can style the docu as we want using Jekyll
  • in the long term we can add a blog;
  • it is still Markdown so the migration should be very smooth;

Third party UI toolkits

Think about supporting third party UI toolkits, such as, but not only, http://wpftoolkit.codeplex.com.
Both for Desktop and Universal Apps.
Our goal should at least to provide basic integration for the UI Composition framework or specific feature for Universal Apps

Documentation paths

I think we should introduce well-known documentation paths, we have the quick-start and the VS templates, in both cases the dev reaches the same result a running application that does nothing.

In order to drive the dev in the right direction, where right in my opinion means "adhere as much as possible to the MVVM tenets", we should add the concept of "What's next", or some way to drive the dev exploring the documentation.

Which type of devs look at our documentation? Personas:

  • new devs that have never adopted MVVM;
  • devs coming from a different toolkit;
  • experienced MVVM devs;

What do they expect as docs?

Reverse the DI container configuration responsibiltiy

We have a strong dependency on a DI container, like it or not that's a fact.

Given the way things are actually designed implementing support for a container is a nightmare that comes to life. It is up to the user to understand what to register, how, when, and how to deal with BootstrapConventions. It is everything but a trivial task.

Now that we are going in the direction of a high level, DI container independent, ApplicationBootstrapper (See RadicalFx/Radical.Windows.Presentation#21 and RadicalFx/radical-universal#28) that utilizes a IContainerBootstrapper implementation as a mediator when talking to the DI container, I'm wondering if there is any value in moving the responsibility of deciding what to register, and how and when, to the ApplicationBootstrapper making the IContainerBootstrapper responsible for the physical registration only.

The clear advantage is that we move in the direction of making the task of implementing support for a new container a trivial task.

@micdenny thoughts?

Domain registration for Radical

Currently everything is hosted under "topics.it" as radical.topics.it. I think we should move away from my domain and register a dedicated one.
Unfortunately "Radical" is a very common world :-|

  • radicalframework.com;
  • radicalframework.it;

ideas are welcome :-)

"Emergency" lanes?

Our very simple process states:

  • no one can commit directly to master or develop
  • changes can come through via PRs only (a fork or a branch)
  • no one can merge their own PR, a review is required

So far so good, lovely.

Now, the issue (or at least potential issue) of the 4-eyes merge process in our scenario depends on the fact that we are not full time committed to the project, obviously. For the sake of the sample take into account the following scenario:

  • A user raises a bug
  • the triage process identifies the bug in the Presentation-something package
  • in order to fix the bug, though, a change in an upstream package is required, say Radical

So:

  1. create a PR in Radical
  2. wait for the PR to be merged, at least in develop, so to publish the package to the MyGet feed
  3. update packages in the downstream repo
  4. create a PR in the downstream repo to fix the bug
  5. wait for the PR to be merged, at least in develop, so to publish the package to the MyGet feed
  6. Ask the user to test the fix in their environment using the MyGet feed
  7. if OK repeat for master branch

Any way to improve the above scenario?

  • we could publish, to MyGet only, the package even if the PR is not merged yet adding to the package name the source branch name as well, pollutes the MyGet feed but solves the above scenario very easily
  • AppVeyor publishes for each project a NuGet feed with the artifacts of the build process, we could add that to our Visual Studio environment, but not for PRs
  • each time a PR is built the resulting artifacts, thus the NuGet package as well, are stored by AppVeyor on the build server, the developer could manually download them and host them on a local/offline NuGet server
  • the local build process could be tweaked to create packages as well so that everything can be tested locally before any push/PR

The latest one is my preferred approach.

Can we benefit of the new protected branches feature?

We can now enable 2 things:

  • Enforce checks on branches, such as CI build must not fail in order to be able merge
  • Restrict the group that can push/merge to certain branches, such as master or develop

The latter could be interesting because we could enlarge the team

Update Radical.CQRS logo

  • All Radical.CQRS readme files
    • Radical.CQRS.EntityFramework
    • Radical.CQRS.Server
    • Radical.CQRS.Handlers
    • Radical.CQRS.Client
    • Radical.CQRS
    • Radical.CQRS.Messages
    • Radical.CQRS.NHibernate

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    ๐Ÿ–– Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. ๐Ÿ“Š๐Ÿ“ˆ๐ŸŽ‰

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google โค๏ธ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.