Closed. This question is opinion-based. It is not currently accepting answers.
Want to improve this question? Update the question so it can be answered with facts and citations by editing this post.
Closed 2 years ago.
Improve this question
I've been developing modules for DNN since version 2 and back then I was able to easily able to run my module as I developed it on my environment and still easily deploy my module as a DLL.
When version 4 came out and used the web site solution (rather than the Web Application solution). It seems like there was something lost. I can continue to develop in my test environment and immediately see changes as I make them, but releasing for me has become a headache.
I mostly do my development for one site in particular have just been using FTP deployment of the modules to the main site after I was done making changes.
I'd like to set up a good environment for multiple developers to be able to work on the module(s).
When adding stuff to source control, are people generally putting all of DNN into source control so they can bring the whole solution down to work on, or just their module and each person needs to set up their own dev DNN environment?
I'd like to start getting my modules projects organized so more people could work on them and I feel a bit lost for some best practices both in doing this and deploying those changes to a live site.
I have a few detailed blog postings about this on my blog site, mitchelsellers.com.
I personally use the WAP development model and I do NOT check the DNN solution, or any core files into source control, as I do NOT modify the core for any of my clients. When working with multiple people we create a similar environment for each person, and still can work with each of our individual projects, at times we will have completely isolated dev environments with individual databases and code, at other times I have worked with a shared dev database to resolve issues with dev module installation issues.
With the WAP model I use a method to dynamically create my installation packages on project build using a post-build event and then I have a test installation that I use to validate that the packages occur. Debugging is then done via Attach to Process.
I would suggest Mitchel book if you are needing some reference material - Professional Dotnetnuke Module Programming by Wrox Module Programming - Michel Sellers
Related
Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
We don’t allow questions seeking recommendations for books, tools, software libraries, and more. You can edit the question so it can be answered with facts and citations.
Closed 2 years ago.
Improve this question
I and my friend want to create a website. We're using Vs code. How we can work on the same code in vs code? I'm looking for something that lets me edit on the code at any time I want and the same thing for him.
Use GitHub
GitHub is a development platform inspired by the way you work. From open source to business, you can host and review code, manage projects, and build software alongside 50 million developers.
Github is a web-based platform used for version control. Git simplifies the process of working with other people and makes it easy to collaborate on projects. Team members can work on files and easily merge their changes.
You should definitely make your account on github as a developer as it helps alot.
Check it out here: https://github.com
You can use https://github.com/. Once you are done doing your code you have to upload it on github. Same as your friend can do. And the important thing is you can see/undo your previous code if you do anything wrong.
This is an opinionated question and answer, but since you are using VsCode, I would recommend Microsoft's Live Share . Since Microsoft is the creator of VsCode, I would guess this is going to be your best option to stay within the editor.
Visual Studio Live Share enables you to collaboratively edit and debug with others in real time, regardless what programming languages you're using or app types you're building. It allows you to instantly (and securely) share your current project, and then as needed, share debugging sessions, terminal instances, localhost web apps, voice calls, and more! Developers that join your sessions receive all of their editor context from your environment (e.g. language services, debugging), which ensures they can start productively collaborating immediately, without needing to clone any repos or install any SDKs.
Additionally, unlike traditional pair programming, Visual Studio Live Share allows developers to work together, while retaining their personal editor preferences (e.g. theme, keybindings), as well as having their own cursor. This allows you to seamlessly transition between following one another, and being able to explore ideas/tasks on your own. In practice, this ability to work together and independently provides a collaboration experience that is potentially more natural for many common use cases.
Well, I would recommend GitHub, is a great tool. If you like to learn from video, I would recommend this video. Or read this article.
The best way is live share
Live Share is an extension for VS Code that enables real-time collaboration between developers. It gives users the ability to share a session with someone else, allowing them to edit code as well as share a sever and debugging session
Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
We don’t allow questions seeking recommendations for books, tools, software libraries, and more. You can edit the question so it can be answered with facts and citations.
Closed 7 years ago.
Improve this question
First of all, we're all beginners, so I am really sorry if this is a trivial question.
We're developing a game in Unity3D. We have two programmers, and one artist. We'd like to make our life easier by not just simply communicating via Facebook and sending our stuff back and forth. I know about GitHub, but I have a couple of problems with it.
It's not free for closed source projects - which would be ideal. Is there an alternative? Is this even the right kind of site to use?
Stupid reason, but I just can't comprehend how it works/how to use it. Is there an easy tutorial for it or something?
Is it even 'compatible' with Unity3D? Since I don't really know how
GitHub works, this might also be a really stupid question.
First of all you can use Bitbucket to host your stuff. Its like github without the open source community.I'm using it on a similar project I'm working on with some guys. It's important you understand that git is version control software developed by Linus Torvalds (creator of the Linux kernel). Git can be used to "commit" changes to a project. Then your other coder could grab those code(script in unity?) files and load them into him project. It is kind of overwhelming to learn to use at first, but it gets easy once you get it. Really learning to use git is one of the best things you can do for yourself.
As far as using git goes, I use linux so I can just 'man git' to look at commands and then use said commands in the shell. Mac uses bash so it probably is run right from the shell there too. Honestly I don't know at all for windows.
Here are a couple of resources:
https://try.github.io/levels/1/challenges/1
https://www.youtube.com/watch?v=TI3yVcSahzk
If I had more time I would look for a really good one for you, but I'm going to be late for work!
I have developed some Unity3D projects using GitHub before. So to answer question 3 and the last part of 1 first, yes Unity projects use a file-system architecture that is perfectly compatible with GitHub and once your used to it it is a great tool for team development.
Answer for question 1:
GitHub is just a name brand for a centralized version control system and there are other brands out there with similar offerings such as bit bucket. Google this term for more info. also look into distributed version control as well.
In all honesty though, if your new to developing, the product you will be making will most likely not be of much interest to other people on GitHub and your public repository will probably go unnoticed. If you believe that what you are creating is of such great value it needs to be kept secret, then investing a few dollars a month in a premium service is recommended anyway.
For other options, one would be to set up a central Git repository on a server (or one of your home computers) that you or one of you project mates is running. This might be a more complicated method but you would learn a lot of other useful things along the way.
Answer for question 2:
See -https://guides.github.com/activities/hello-world/- for github's intro tutorial. Also Youtube has some decent offering if you search for how to use Git Hub.
It can be a little daunting to work with something new and attempt to understand the documentation. If you are planning on getting serious about development though, especially in a corporate setting, you need to learn GIT and practice reading and understanding documentation.
Good Luck!
I recommend git for just about any text-based version control. If the files are binary heavy, it still works but it's not git's strength.
Until you get the central hosting worked out, you can use git bundle to share the changes offline.
Closed. This question needs to be more focused. It is not currently accepting answers.
Want to improve this question? Update the question so it focuses on one problem only by editing this post.
Closed 6 years ago.
Improve this question
What is continuous integration and what are its benefits?
This is by far the best explanation I have read so far.
At its simplest, it is simply a mechanism that rebuilds your project whenever a check in is made into some revision control system (CVS etc). This can be extended though to include running tests, all the way through to generating a CD image, mounting it within VMs, installing the product and running full tests on it.
It has the simple advantage of highlighting when code changes break the system as early as possible. Not only does it detect breaks in the code, it highlights who caused the break. This psychological effect is very effective in encouraging good testing prior to check in!
It is the practice of ensuring that all aspects of your software development process are lined up to permit the daily creation of a working version of your product. It is best known as part of Extreme Programming.
This involves things as far afield as build automation, automated testing, daily check-ins, using a source code repository, etc. But the ultimate goal is to help the entire project run according to core Agile Principles so that you deliver early and often. This, in turn, helps you leverage feedback from your users, etc.
+1 for the link to Fowler's page.
Personally, I just found it "nice" to know whenever something didn't compile because we had the poor practice of having a single build (yes, we developed on the production build; we were awesome). We hadn't got the integrated testing phase before I left.
After a while, it did, however, lessen the amount of massive coding changes (compared to the "check in and pray my changes don't conflict" that was rampant). Eventually, most developers started making small changes frequently just to get confirmation from the CC.Net tray icon.
Overall, I found it very comforting to know that we could send out a build immediately if we had to. Had we had just a few smoke tests integrated, I think the stress-level would have been substantially lower.
Just to refresh. At this point there is a huge difference between Continuous Integration (CI) and Continuous Delivery (CD). While most of posts above described CD I'll try to show how CI extends now CD definition. Having all the tools needed to build a package and deploy new version of app automatically is a crucial part of CD. Adding to that test automation (based on three level verification: General Health-check, Detailed Statistics and Historical entries) and a proper governance you're creating a really good piece of CI. Only because of such an extended definition building extraordinary cloud tools is possible. Think about muleESB or esbeetle.com. For both of them CI is something natural although only the second one is supporting both ESB and ETL components.
I hope that it was helpful.
Closed. This question is opinion-based. It is not currently accepting answers.
Want to improve this question? Update the question so it can be answered with facts and citations by editing this post.
Closed 6 days ago.
Improve this question
In an ideal world, our development processes would be perfect, resulting in regular releases that were so thoroughly tested that it would never be necessary to "hotfix" a running application.
But, unfortunately, we live in the real world, and sometimes bugs slip past us and don't rear their ugly heads until we're already busy coding away at the next release. And the bug needs to be fixed Now. Not as a part of the next scheduled release. Not tonight when the traffic dies down. Now.
How do you deal with this need? It really can run counter to good design practices, like refactoring your code into nice, discrete class libraries.
Hand-editing markup and stored procedures on a production server can be a recipe for disaster, but it can also avert disaster.
What are some good strategies for application design and deployment techniques to find a balance between maintenance needs and good coding practices?
[Even though we test a lot before we release, ] What we do is this:
Our SVN looks like this:
/repo/trunk/
/repo/tags/1.1
/repo/tags/1.2
/repo/tags/1.3
Now whenever we release, we create a tag which we eventually check out in production. Before we do production, we do staging which is [less servers but] pretty much the same as production.
Reasons to create a "tag" include that some of the settings of our app in production code are slightly different (e.g. no errors are emailed, but logged) from "trunk" anyway, so it makes sense to create the tag and commit those changes. And then checkout on the production cluster.
Now whenever we need to hotfix an issue, we fix it in tags/x first and then we svn update from the tag and are good. Sometimes we go through staging, with some issues (e.g. minor/trivial fixes like spelling) we by-pass staging.
The only thing to remember is to apply all patches from tags/x to trunk.
If you have more than one server, Capistrano (link to capify.org doesn't go to the intended anymore) is extremely helpful to run all those operations.
One strategy is to heavily use declarative-style external configuration files for the different components.
Examples of this:
Database access/object-relational mapping via a tool like IBatis/IBatis.NET
Logging via a tool like JLog/NLog
Dependency injection via a tool like Spring/Spring.NET
In this way, you can often keep key components separated into discrete parts, hotfix a running application without recompile, and seamlessly use source control (particularly in comparison to stored procedures, which usually require manual effort to source control).
We divide our code in framework code and business customizations. Business customization classes are loaded using a separate classloader and we have tool to submit changes to a running instance of production. whenever we need a change in any class we change it and submit it to a running instance. the running instance will reject the old classloader and use a new classloader insance to load the classes again. This is similar to Jboss hot deploy of EJBs.
Closed. This question is opinion-based. It is not currently accepting answers.
Want to improve this question? Update the question so it can be answered with facts and citations by editing this post.
Closed 3 years ago.
Improve this question
At work we have 4 people working together on a few different projects. For each project we each have a local copy we work on and then there is a development, staging, and live deployment, along with any branches we have (we use subversion). Our database is MySQL.
So my question is, what is a good way to manage which revisions to the database have been made to each deployment (and for the developers their local copies). Right now each change goes into a text file that is timestamped in the name and put into a folder under the project. This isn't working very well to be honest.. I need a solution that will help keep track of what has been applied where.
http://odetocode.com/Blogs/scott/archive/2008/01/30/11702.aspx
The above blog brought us to our current database version control system. Simply put, no DB changes are made without an update script and all update scripts are in our source control repository.
We only manage schema changes but you may also be able/willing to consider keeping dumps of your data available in version control as well; creating such files is a pretty trivial exercise using mysqldump.
Our solution differs from the solution presented in the blog in one key manner: it's not automated. We have to hand apply database updates, etc. Though this can be slightly time consuming, it postponed some of the effort a fully automated system would have required. One thing we did automate however, was the db version tracking in the software: this was pretty simple and it ensures that our software is aware of the database it's running against and will ONLY run if it knows the schema it's working with.
The hardest part of our solution was how to merge updates from our branches into our trunk. We spent some time to develop a workflow to address the possibility of two developers trying to merge branches with DB updates at the same time and how to handle it. We eventually settled on locking a file in version control (the file in question for us is actually a table mapping software version to db version which assists in our manual management strategy), much like you would a thread's critical section, and the developer who gets the lock goes about their update of the trunk. When completed, the other developer would be able to lock and it is their responsibility to make any changes necessary to their scripts to ensure that expected version collisions and other bad juju are avoided.
We keep all of our database scripts (data and schema/ddl) in version control. We also keep a central catalog of the changes. When a developer makes a change to a schema/DDL file or adds a script that changes the data in some way, those files are added to the catalog, along with the SVN commit number.
We have put together a small utility in-house that reads the catalog changes and builds a large update script based on the contents of the catalog by grabbing the contents from each revision in the catalog and applying them. The concept is pretty similar to the DBDeploy tool, which I believe originally came from Thoughtworks, so you may be able to utilize it. It will at least give you a good place to start, from which point you can customize a solution more directly suited to your needs.
Best of luck!
If your database maps nicely to a set of data access objects, consider using 'migrations'. The idea is to store your data model as application code with steps for moving forward and backward through each database version.
I believe Rails did it first.
Java has at least one project.
And here's a .NET migration library.
To change versions, you run a simple script that steps through all of the up or down versions to get you to the version you want. The beauty of it is, you check your migrations into the same source repository as your app code - it's all in one place.
Maybe others can suggest other migration libraries.
Cheers.
Edit: See also https://stackoverflow.com/questions/313/net-migrations-engine and .NET database migration tool roundup (from above post).