Related
A small ma and pa shop came to me recently with a request to update a vb6 program one of their former part time employees made for them while home from college. On the cd the student provided is both the source code and a installer for the program, which extremely helps. I would like to just give them a new cd with a new installer and the updated source code. My question is, how do I go about creating or if easier updating a installer for a language that entered "Non Supported Stage" back in 2008?
Update:
Just to answer some of the questions, the updates they are asking for are just changing the wording of some labels and changing one control from a textbox to a combobox. They are a ma and pa shop and don't want to pay the cost to have the app re-written to a newer language, even though it has been recommended.
You're going to need a copy of Visual Basic 6 (or Visual Studio 6) which is difficult. If you have an MSDN subscription, I'm quite sure you can download it from their archive, but if not, you might need to buy a copy. Check EBay. Have the ma and pa shop purchase it at their own expense, and they should own it in case they want to make future changes. You can use it on their behalf to do work for them, if you're the only one using it, and just uninstall it when you're done.
Also, if you have a copy of Visual Studio 2005, technically you can "downgrade" to VS6 but you have to call Microsoft and have them send you the install program, and you're not allowed to use VS2005 concurrently with VS6. Yeah, I know...
Ok, so if you've got that far, get the source on your computer and get it under source control. I suggest Mercurial (specifically the TortoiseHg client). I've had lots of luck with it on a VB6 project, and it's free. (Don't use SourceSafe, even if it comes free with VS6!) The distributed nature of the Mercurial repository means you can hand them back a CD with the entire repository on it, and the next poor sap who has to make changes will at least be able to do a diff and know what you did.
As someone else here said, VB6 has a built-in utility for making install programs, but I think you had to have the Enterprise version for that. It's worth finding that out before you get a copy.
Now go ahead and make changes, but be very careful. Remember that you probably don't have any unit tests, so you're likely to break stuff. If you want to be professional about it, there are unit testing frameworks out there for VB6. For instance, vbUnit. Again, I suggest having the customer buy a copy (about $99 for a single developer seat, I think). If the change was anything more than changing the company logo on the splash screen, then this is something I'd invest in. Write tests that cover every module or feature you're going to change. If all the logic is in event handlers in the form itself, carefully remove the code you need to change out into modules that you can write unit tests for. Write the tests to verify the current functionality first.
Then go ahead and make your changes. If you've gone to the trouble of setting up a testing framework, then you might as well use some TDD and write your tests first. Write a test, make sure it fails, write enough code to make it pass, and repeat.
All of this still requires you to have a solid manual test plan to check the functionality at the end. That means you need a solid grasp of what it does. You can pretty much assume that no matter how careful you are, you'll break something you didn't understand. Make sure to give yourself enough time to fix other problems that pop up after you deliver it.
I recommend against re-writing it in .NET unless it's a really simple program with only one form. The effort likely isn't worth it.
Caveat: beware of 3rd party components the original programmer might have used, but not included on the CD. If they used some ActiveX or COM stuff that they purchased from a 3rd party, but they didn't license it to your customer, you might have to end up purchasing it again just to get it to compile.
EDIT:
Based on your extra information, if you're really just changing a couple of controls and wording, then I think you can get away without a unit testing framework. I would definitely use some source control though.
I do remember using the Package and Deployment Wizard, and I agree it sucked. I actually used a 3rd party installer, now that I think about it. However, if the changes are small and the original application used the PDW, I'd probably stick with that.
You Can Convert VB6 projects to .NET.
If you have Visual Studio 2005 or higher...
Or the worse case is re write the code using VB.NET.
Go to this Link.
Convert VB6 - .NET
If I recall correctly, Visual Studio 6 came with a rudimentary wizard for creating an installation program for a VB6 application. So, assuming that you have Visual Studio 6 installed for VB6, there should be an installer wizard that you can use. However, it may have problems deploying the VB6 runtimes on Vista or Win 7 machines. Perhaps another SO guru will have the answer to that one.
You can also use the freeware Inno Setup to create an installer for a VB6 application. More information can be found here. However, it requires more manual effort than what came with Visual Studio.
I am currently using VS2010 Premium, and have heard that the debugging in Ultimate is so much better. Is it really worth upgrading to Ultimate to take advantage of the new debugging features they've included? Or is it marketing hype and not really usable for every day development scenarios?
I believe the feature is called IntelliTrace.
Do you work in a team? Do you get bugs reported to you by a tester, and then you can't repro them? Would it save you a lot of time to be able to "debug" through the actual setup the tester had - see their values and execution path? Or perhaps you work with another developer. Would you like to be able to set a bunch of breakpoints and leave "notes" in the code (pinned data tips) and then export them and give them to the other developer, saying "the bug we're looking for is in your part of the code".
If those scenarios cause you pain now, you want Ultimate. If you work alone, it's possible that IntelliTrace alone will make you want Ultimate. It is cool to "time travel" in the debugger.
If you are heavily working on Linq to SQL / Linq to entities then IntelliTrace feature will surely helpful.
Then you should upgrade.
they have quite a few named advantages in this site http://c.ittoolbox.com/groups/technical-functional/csharp-l/whats-new-in-vs2010-and-is-it-worth-upgrading-3531098#M3669289
IntelliTrace is the only way to download the crash and other event logs from Windows Azure. The devFabric isnt quite a 100% representation of the azure deployment environment. I have used the Intellitrace to find deployment flubs quickly. When everything takes 20 minutes to deploy, having a tool that saves you 1 or 2 deployment cycles pays for itself quickly.
I've become a bit of a TDD zealot lately. Explaining the concept isn't the hard part. Most people respect the purpose behind it. However, when I try to demonstrate the actual process behind the idea, the biggest complaint is:
"When I'm writing my initial tests, I hate how Visual Studio intellisense
tries to guess what I'm doing. It's obviously going to be wrong because I haven't
written the API yet. It takes me out
of context when I have to fix all the things that
Intellisense has guessed incorrectly."
which, unfortunately often comes out as:
"TDD (or Visual Studio) sucks"
It's never really bothered me before (I just delete the stuff it guesses wrong), but I see the problem. What has everyone else done to get around this issue? Obvious answers are:
Turn off intellisense when writing tests, then turn it back on when writing the API.
Write your tests in something like Notepad++, then copy into VS when you think you're happy
Stop whining
P.S. I looked everywhere on SO (and elsewhere) for this question so feel free to flag as duplicate if I missed it... As if you needed my permission ;-)
Edit: And, yes, I have Resharper, it's awesome.
Learn to use the Esc key and start to think about what you are programming. Intellisense is a double edge sword in that it both speeds up your coding but it also causes people to stop thinking about what they are doing. TDD is all about thinking, not mindlessly allowing the IDE to do your work for you. When the little pop-up Intellisense box appears, just hit Esc and it goes away without filling anything in.
Also, get Resharper. This is absolutely mandatory for programming in Visual Studio, but doubly so for TDD.
(Btw, Visual Studio does suck).
Learn to ignore the Intellisense, and get ReSharper. Then write the code you want and let ReSharper create the shells into which you'll eventually author your implementation code.
Err... Correct me if I am wrong but I personally love intellisense on the fly code analysis. Especially in conjuction with Resharper it makes TDD a real fun process. You write a test with not yet defined classes and methods, then extremely fast generate stubs using Resharper, make it compile, then add functionality to the point when your test runs successfuly, then you refactor as needed and rinse and repeat.
Turn Intellisense off temporarily.
From the menu it's: Tools..Options..Text Editor and then turn off "Auto List Members" and "Parameter Information".
And if your company is willing, have them purchase NCrunch extension for you guys. If they are not, try convincing them. It is a concurrent test runner and it cuts traditional TDD time in half (for me). Not having to go back and run the test after writing the implementation, or getting what the exception (assert exceptions) are right on the editor, and getting feedback right away as you write your code is simply amazing! I think this tool makes a switch to TDD much easier. I feel TDD with RGR approach is quite tedious and time consuming (without NCrunch), very much worth it though. As a point in Joel Test says, "buy the best tools money can buy" (I am aware of company budget approval is another tedious thing).
I saw that Beta 1 of VS2010 was publicly availible.
My question to those of you who has tried it is: does it work good?
Will it cause my computer to blow up in tiny pieces? Will it crash randomly? Will it work with some minor glitches? Or is it just perfect from bottom up?
I'm only coding school- and hobby-stuff, so nothing that someones life depend upon, but i still want software that works. How close to a final product is it? Is it worth trying?
It's a bit slow, and there's no offline MSDN, but it's worth trying IMO. Having said that it's slow, I still use it on my NC10 netbook, so it's clearly not that bad :)
I've got it side-by-side VS2008, and that hasn't caused any problems.
I've seen a couple of glitches (once the keyboard handling went completely wonky) but it's certainly usable. The main question is what you want to get out of trying it - in my case I absolutely need to code against C# 4 to explore the new features. I do most of that from the command line in fact, where the speed of VS obviously isn't an issue, but it's nice to see the VS-specific features as well (like the debug threading views for Parallel Extensions).
It seems more or less usable on the .NET side. The C++ side is a bit more sketchy. On one hand, they've added support for some very nice new C++0x features, on the other, they've broken some absolute fundamentals.
Your plain old main function won't compile in 32-bit with unicode enabled. (Workarounds: Either compile as 64-bit, disable unicode, or rename the function to wmain).
This seems to me to be a strong hint that the C++ side of things is nowhere near release-worthy. I'd probably wait for beta2 before doing any serious work with that.
I would say it is great, but the performance hurts a bit.
Here is an idea for you: Install it into a VirtualPC. Then you can play and not care what it does. You don't like it, delete the VPC image and keep on trucking. That is how I play with Microsoft betas now. I never install them on any real machine - too risky.
Usable: Yes.
Recommended: Not if you'r a touchpad-addict or dislike crashing apps.
I've been trying it for 2 weeks now coding small C#-projects and these are my impressions
Reasons to use 2010:
Looks good
Multi monitor support
I can see myself using the code templating but right now i couldnt find any really useful stuff except for reducing the fontsize of comments.
Zoom in the editor
Select a variable and then press shift+up/down to go to next usage of this variable
Ctrl+, brings up instant search of classes and functions in the entire project. (i've become really addicted to this)
Floating watches for single objects
Reasons to not use 2010:
TOUCHPAD SCROLL DOESN'T WORK IN THE EDITOR!!! (this is reason enough to not upgrade if you are using it on a laptop)
I've had some random app-crashes in the middle of just writing code, once or twice per day maybe.
UI sometimes freezes randomly for about 30seconds and then returns to normal.
It started to use 100% CPU power from one of my cores once when it was minimized in basic editing-mode and i was doing other stuff in other programs, i only noticed it because the fan started to go wild.
Otherwhise it's pretty similar to 2008. I haven't noticed any difference in speed like other people say.
You need to ask yourself: what is the advantage for you in using VS2010 over VS2008? I would suggest that there is no advantage if all you are doing is "school- and hobby-stuff".
I'm still using VS2008 for business related stuff (and, indeed, VC6 for some stuff). I prefer to wait until all the early adopters have tested it (and Microsoft has released at least one service pack after the real product release) before I do their testing for them.
It seems to co-exist with other versions of VS without causing any problems.
Regarding the slowness - it seems to be the UI that is slow, rather than building. Once it's going it doesn't seem much slower on my fast quadcore. I've yet to try it on my laptop.
It's usable enough, the small glitches that I've encounter weren't that bad. However, certain VS extensions(like XNA) don't work in VS2010 at the moment.
It's fun to toy with. Not usable for me, cause re#er does not support it yet (had to install TestDriven .NET which works through keyboard shortcuts only to run my tests).
Gave me an insight how addicted I am. :/
Btw, on Win7, without virtual pc it seemed even faster than vs2008 for me.
VS2010 doesn't yet support mobile device projects, which might or might not matter to you.
VC++ wise - VS2010 has a built-in 64-bit compiler, VS2008 does not.
You can supposedly add 64-bit support to VS2008, but it takes some effort.
I've been using VS 2010 beta (with .NET 4.0 beta) on Windows 7 RC. I've been trying to rewrite parts of a large-scale business application in it to see what can be done with it.
The UI freezes frequently. I'm talking 1-10 minutes between freezes. The UI does not come back, so I'm forced to kill devenv.exe every time it happens. Microsoft probably puts my error reports in their spam folder by now.
For me, VS 2010 beta 1 classifies as unusable. However, it's fast, the new IDE functions are very handy, and it's pretty. I keep coming back to it despite my resolutions to wait for a stable build.
I have an MSDN subscription and I'm wondering what edition of Visual Studio 2008 to get. I recall reading that Team System has a lot of bonus features like doing high-level system architecture stuff, and specialized things related for doing database work. As a solo dev, I wear many hats including database developer and architect - should I use Visual Studio Team Suite to get all of these things, or are they major overkill for a single guy?
EDIT: I have a "special" MSDN license (via the MS BizSpark program for startups) that gives me access to the FULL version of Team Suite for 3 years, for myself and any developers in my startup. After that I have to pay if I want upgrades but I'm free to use it for development indefinitely if I'm okay with not upgrading (per BizSpark licensing).
With that in mind, should I look at Team Suite or stick with Pro? I don't plan to use Team Foundation Server at all.
Well, the "test" stuff is now available in "pro" (but not profiling) so that removes one major comparator. In many ways, the MSDN subscription is a bigger factor than the VS product suite, assuming you don't need the full bredth of tools.
The VS feature list here; the MSDN feature list is here.
I used to use pro, and I never felt I missed much. Of course, you could always get pro plus something like dotTrace for profiling, ReSharper for code analysis/refactoring, and maybe TestDriven.NET for testing - you'd probably still have change left over.
I now have a team suite license (which is very nice), but if I had to pay for it I'd have to think very carefully; I'd probably get developer edition + MSDN.
I'd say that VS Team System is an overkill for single developer sweatshop, but your situation may proves otherwise. Team System is great when you're working on a project where all things are Microsoft, but all the extra features (database, architect, etc) will become useless when you start working with Oracle and MySQL database. Don't put too much stress on the tools, VS Pro is good enough if you want to save money. I'd rather spend more money on extra tools such as third party component and refactoring tools than the shining VS Team System.
But, since you join the BizzSpark program, which I think is really great for startups, I think you should go and try VSTS. You basically pay nothing for the extra features. By the time you need to pay full for the licenses, I think you will gather enough experience on VSTS to decide either to stick with it, or rollback to pro.
It never hurts to have as many toys as possible in your toy box. Sure, you may only play with some of them once in a blue moon but the point is that you have them there to play with when you want to.
I run on a Mac so I have to run all of my stuff off of a VM, and I got to thinking that all I needed was VS installed and then I could use the underlying OS to handle all of my other functions (Dreamweaver, Photoshop, Office, Web Browsing) or in other words my general day to day computing life. Thanks to VMWare the transition between the VM and the host OS is easy, but you get attachments in your email that you want in you VM, or you work on a programming doc on the host os... the list goes on and on and on.
My point is this... you'll never regret putting more into your development system, you will regret not having that one tool that you wanted to have but just didn't think you'd need.
First, you should definitely use a version control product. Being able to go back in time and recall previous builds will save you tons of time and effort. Nothing worse than having it work one day, then realizing a change you made but can't remember broke everything.
Second, if it's just you (or even a couple of other people) you should probably go with subversion. Easy to setup, manage, and interact with is the name of the game here. Not to mention free, fully supported, reliable, and easy to learn.
I have recently started using VisualSVN Server and VisualSVN Client for Visual Studio. The server is free and the client is $45 for a license you can use on every one of your development machines. Add TortuousSVN and you can use the version control from the Windows shell.
I tried the TFS and VSS products from Microsoft and found subversive much easier to deal with.
If you are serious about unit testing your code (you should be) then I'd definitely recommend using the Development Edition, as it provides code coverage, which Professional Edition doesn't.
Sure, you can get most of the functionality difference between Professional & Development Edition from free/cheap 3rd party tools, but IMO these come at a price that is usually higher than what their tag says. Since you may use the even better Team Suite for 3 years I wouldn't even bother looking at the 3rd party tools.
I believe that the Team Developer Edition will now include the Database edition. This is probably all that you would require. From memory, the full Team Suite edition (Developer, Database, Architect and Test all together) is quite an expensive purchase.
One feature from team system which I like is the ability to profile the performance of your application. That might not merit an upgrade in itself if you have to pay for it, but it's very handy in some cases.
I agree with theBadDawg.
I thought it was a travesty when the unit testing features were only available in most expensive editions of Visual studio; unit testing is something everyone should have access to because it benefits us all by instilling good habits in us and helps us write far better software. Especially if we're new to the game.
Fortunately, it's now in the Pro edition.
If you can get the Team Suite and enjoy it's tools to be more productive and produce better quality software from it, do it.
I would agree with #Marc Gravell. You can probably approximate the value of Team System with add-ons, but you also need to factor in the cost of maintaining the add-ons as well. There is some pain associated with maintaining several third-party tools to get the functionality that you could get in an integrated package. Depending on who is spending the money (you or employer), the amount of pain you are willing to deal with to get all the functionality may differ.
I've been very happy with Team System, although I have added in TestDriven.Net as a test runner. We switched to this when TS came out with baked in unit testing, coverage analysis, and source code control. I'm very happy with the choice, but if I had had to pay for it personally, I probably would have gone with nUnit, nCover, SVN, etc. and kept the leftover money. I do feel that it has made me more productive, but I just wouldn't have had that much money to spend.