Next Generation Software Configuration Management with Subversion
Training Duration – 30 Days (90 mins each day)
Mode – Online (Webex | Skype | Gotomeeting)
Mode of Payment – Online Bank Transfer (Send us an email to email@example.com with the confirmed payment receipt for acknowledgement)
Registration is based on First Come basis and only confirmed registration would be considered.
Course Materials – Would be shared everyday end of the session every day
Lab – 70% of the training consist of lab.
Demo Class – ScmGlaxy team does not believe in demo class concept as this is very difficult to evaluate any training/trainer very first day in 90 mins. Still, if you want to experience our training before enrollment, we may add you in any on-going live class based on your special request. If you want to know more about us – Click here
Refund – If you are reaching to us that means you have a genuine need of this training, but if you feel that the training does not fit to your expectation level, you may cancel your training within first three days of class and 100% refund will be processed.
What if you miss the scheduled class? – If you miss the scheduled class, you can be a part of other ongoing batches any time in future free of cost.
scmGalaxy Advantage – If you enroll for our courses, you can attend for our training any number of times of that specific course free of cost.
Weekdays Class Timing(Mon-Fri)
|8:00 AM – 9:30 AM||11.30 AM – 01:00 PM||11:00 PM – 12:30 AM|
|06:30 PM – 8:00 PM||10:00 PM – 11:30 PM||09:30 AM – 11:00 AM|
|10:00 PM – 11:30 PM||1:30 AM – 3:00 AM||1:00 PM – 2:30 PM|
Weekend Class Timing (Sat – Sun)
|11:00 AM – 2:00 PM||2:30 PM – 5:30 PM||2:00 AM – 5:00 AM|
Tools Covered as Part of this Training – Jenkins, Git, SVN, Ant, Maven, MSBuild, Chef Fundamental, RPM, Shell Scripting and Linux
Course Outline :
Concept / Process / Principals / Overview
- Software Configuration Management overview
- Elements of Software Configuration Management
- Introduction of Version management / Source Code Management
- Overview of Build management
- Overview of Packaging management
- Overview of Release and Deployment management
Source Code Management Tools
Build Management Tools
- Apache Ant – A java based build Tool
- Apache Maven – A java based build tool
- Msbuild – A dot net based build tool – Fundamental only
- Jenkins – A continuous integration tool
Application Packaging Management Tools
- RPM – A linux based application packaging tool
Deployment Management / Configuration management – Fundamental only
Application server – Fundamental only
- Jboss – An open source application server
- Windows – A Microsoft operating system
- Linux – An open source operating system
CI/CD Concept and Implementation
- Concept of Continuous Integration
- Concept of Continuous Deployment
- Concept of Continuous Delivery
- CI/CD Implementation
TABLE OF CONTENTS
Which of the following do you get from your existing process?
· Artifact templates
· Activity descriptions
· Artifact descriptions
- What is the size of each project (duration, persons, person years, LOC)
· What type (maintenance / enhancement / new development / prototype /
- What type of development model is being used?
- Are we using any process models like UCM, RUP or any other?
- Any industry/domain specific standards (like CMMI, ITIL etc.) to be followed?
· What are the tools that you currently use in your work?
· How is the integration among the above tools?
· Are we using the tool features the way they are designed or intended?
· How do you maintain all the artifacts together and version them?
· Where are the people working on the project located?
· What’s the difference between Developer CM and Release CM?
· How do you assess, and track the impact of a proposed change?
· How do you manage system integration of modules developed by individual developers?
· How many product versions are you supporting at this moment?
· Who is the designated Configuration Manager?
· How do you baseline project artifacts?
· Can you build your system reliably and repeatedly?
· Explain your labeling scheme?
· Can you show me what versions went into a certain release?
· What does the version tree for this file look like?
· How many product versions are you supporting at the moment?
· What is the version control tool being used? Is it user friendly?
· What is the bug tracking/change management tool being used? Is it user friendly?
· Do you know what files/documents should be delivered?
· How do you assess, and track the impact of a proposed change?
· Can you show me what artifact versions went into a certain release?
· How comfortable are you working with Bug/Change management tool?
· Do you know what files/documents should be delivered?
· How do you track who changed what, when, where, and why?
· How long does a build or release take?
· Is there a Configuration Management Plan document?
· Is there a tight integration between Version control tool and Bug/Change tracking tool?
· How the parallel (if any) development is enabled? Any limitations with the current branching strategy?
· Is this project development spanned across multiple sites? If so, what is your multi-site strategy?
- What is the build process adopted (automated/manual)?
- Are there nightly builds?
- Is there continuous integration?
- Are there smoke and sanity tests at the end of the build?
- What is the build acceptance criterion (BAT)?
- What is the build duration? Is it optimal?
- How are pre-conditions to the build verified?
- Are there any build environment integrated automated unit test-cases?
- Is there any enforcement tool on coding standards?
- Is there any code coverage tool being used?
- Are the post build activities automated?
- Any additional practices (like checksum generation, signing the build artifacts) in place as part of the build?
- Are there any scripting technologies used in automating build process?
- Is Labeling strategy well-defined?
- If any third party tool is being used for packaging, is that package creation process automated?
- How many major, minor releases a year per project?
- How many customers per release per project?
- How do you deliver the releases to the customers? – Is it physical media distribution or Push/Pull mechanism from web or any other process?
- Is the distribution CD/DVD creation process automated?
- What is the size of the release deliverable?
- What are the contents of a release?
- How is the release bundle tested?
- How many platforms are certified? How different are the release packages?
- Is there any release check-list for cross-check?
- Is any part of the release process automated?
- Is there a need for i18n? If yes, is the i18n release handled separately?
- In case of installers, is there installer testing? Is it automated?
- Is the release schedule well-planned?
- Are you delivering patches in well constructed and cost effective way?
- Is there any release audit process in place?
- How are you tracking your releases?
- Is there any legal compliance in place while shipping the release to the customers?
Identification, control, audit, and status accounting are the four basic requirements for a software configuration management system. These requirements must be satisfied regardless of the amount of automation within the SCM process. All four may be satisfied by an SCM tool, a tool set, or a combination of automated and manual procedures.
- Identification—Each software part is labeled so that it can be identified. Furthermore, there will be different versions of the software parts as they evolve over time, so a version or revision number will be associated with the part. The key is to be able to identify any and all artifacts that compose a released configuration item. Think of this as a bill of materials for all the components in your automobile. When the manufacturer realizes that there has been a problem with parking brakes purchased from a subcontractor, it needs to know all the automobile models using that version of the parking brake. It is the same with software. If we are building a multimedia system that has audio MPEG3 drivers for Windows 98, Windows 2000, Windows CE, Linux, and FreeBSD operating systems, how do we find out which releases are impacted when we find an error in the Linux product? You must go back to your SCM system to identify all the common components in all operating system releases that are impacted.
- Control—In the context of configuration management, “control” means that proposed changes to a CI are reviewed and, if approved, incorporated into the software configuration. The goal is to make informed decisions and to acknowledge the repercussions associated with a change to the system. These changes may impact budgets, schedules, and associated changes to other components. If a problem is reported in a released product, software engineers must act quickly to evaluate repercussions—a “fix” for one client’s version of the product may be dangerous to another. The control inherent in an SCM system shows each version in which the flawed component appears.
- Auditing—Auditing an SCM system means that approved requested changes have indeed been implemented. The audits allow managers to determine whether software evolution is proceeding both logically and in conformance with requirements for the software. The SCM system should document changes, versions, and release information for all components of each configuration item. When such documentation is in place, auditing becomes a straightforward analysis task.
- Status accounting—Reports and documentation produced by the status accounting function are the auditable entries. All approved parts of a software configuration must be accounted for, and the software parts list must reflect the transition from part CIn to CIn+1. This accounting provides the historic information to determine both what happened and when on the software project. Status accounting enables the auditing requirement of the SCM. As a project manager, the status accounting holds a wealth of information on the amount of effort required throughout the life cycle of the product in its development and maintenance. This is critical to the software project manager in making estimates for new systems based on historic information. The SCM can be used as one of the key components of the project managers’ metrics system.
The minimum features for SCM tools are closely related to the task of handling the different product deliverables produced within the project software engineering process. Tool requirements and selection criteria are based on a series of features that provide a consistent look and feel with state-of-the-art software development environments. An SCM tool must have multiuser support, an intuitive graphical user interface, conformity to the organization’s development environment, scalability, flexibility in integrating other software development tools, ease of setup, modifiable models, process management, extensive support for the development phase, and management of nondevelopment objects.
Basic selection criteria includes the following:
- Multiuser support—Tools are to be used concurrently by several users. They have to store all acquired information in a central, shared repository, and the SCM tool has to allow controlled parallel work on the different project documents.
- Intuitive GUI—Because the tools will be used throughout the project and not only by developers, an intuitive, easy-to-use graphical user interface is considered very important.
- Conformity to the organization’s development environment—The organization must define up front the hardware and software development platforms used. For example, the project may work on a heterogeneous network of Unix-based workstations (mainly Sun Sparc stations) and PCs. The workstations may be used for some part of the development and as a file server and communication server. The PCs may be using MS Windows 2000 NT. PCs and workstations may be interconnected using the NFS protocol (especially Sun PC-NFSpro on the PCs). The tool has to be able to store its shared repositories on a workstation and has to allow PC clients as well as workstation clients supporting the operating systems and protocols.
- Scalability—The tool should work equally well for smaller projects as for larger ones.
- Flexibility in integrating other software development tools—The tool must allow the integration of all the other development tools to provide a highly homogeneous environment. Especially the tools for design, implementation, and testing will have to co-operate on the common SCM repository.
- Ease of setup—The SCM tool should allow an easy installation and setup, and should be able to run nearly “out of the box.” It should contain predefined, immediately usable models describing the types of items, the life cycle, and the roles of the different users. The importance of existing projects and their directory structures should be made as easy as possible.
- Modifiable models—Though a working set of models should be predefined, each of these should be modifiable and extensible. This is especially important because project managers and developers want to adapt these models to the software development process as defined for the company. Role models must be adapted to the roles assigned to the different employees on the project. Object-type models must be extensible to reflect different types of objects used in the environment and especially with respect to nondevelopment objects.
- Process management—Process management comprises efficient support of object life cycles and object promotion, together with a flexible and extensible approach to life cycle models. Based on a concept of object types, it should be possible to attach different life cycles to different types of objects.
- Extensive support for the development phase—During development when checkout and update of objects is frequent, the tool should aid a developer in determining the set of objects that need an update or renewed check-in. Although this requirement seems to be trivial at first, the latest version of the tool you plan to use must be evaluated with emphasis on the environment prior to the first build. These do a good job in change management once the first release has been produced.
- Management of nondevelopment objects—SCM tools must manage all artifacts of the project, not just code. These will mainly be documents and their versions and releases. The tool must be able to support that.
- Permission management—Everyone should not have access to make changes to different pieces of the software. In many situations, check-in and checkout only will not prevent integration from being broken by multiple people modifying code for their own designs and interfaces.
Many configuration management tools in the market promise to fulfill more or less all of the requirements. Chapter 24, “Use of Tools,” presented a general model for the selection of tools to support software development and project management. The keys to any tool selection are to know your project’s tool requirements, to understand how tools relate to the project’s success factors, and to do a current market search for tools. The following is an example of using that tool selection method for an SCM tool. This is simply an example, and it must be updated with individual key project success factors, tool requirements, and the tools available in the market based on the project’s schedule requirements.
Versioning in Software Configuration Management?
Reference: This article has been take out from Book Called “The Build Master: Microsoft’s Software Configuration Management Best Practices”
Why Worry About Versioning?
- Having a good version scheme for your software is important for several reasons. The following are the top five things a version scheme allows you to do (in random order):
- Track your product binaries to the original source files.
- Re-create a past build by having meaningful labels in your source tree.
- Avoid “DLL hell” —multiple versions of the same file (library in this case) on a machine.
- Help your setup program handle upgrades and service packs.
- Provide your product support and Q/A teams with an easy way to identify the bits they are working with.
So, how do you keep track of files in a product and link them back to the owner? How can you tell that you are testing or using the latest version of a released file? What about the rest of the reasons in the list? This chapter describes my recommendations for the most effective and easiest way to set up and apply versioning to your software. Many different schemes are available, and you should feel free to create your own versioning method.
Ultimately, like most of the other topics in this book, the responsibility to apply versioning to the files in a build tends to fall into the hands of the build team. That might be because it is usually the build team that has to deal with the headaches that come from having a poor versioning scheme. Therefore, it is in their best interest to publish, promote, and enforce a good versioning scheme. If the build team does not own this, then someone who does not understand the full implications of versioning will make the rules. Needless to say, this would not be desirable for anybody involved with the product.
What is the best way to accomplish this? Let’s start with the version number and work our way down.
Every file in a product should have a version number; a four-part number separated by periods such as the one that follows seems to be the established best practice. There are many variations of what each part represents. I will explain what I think is the best way of defining these parts.
<major version>.<minor version>.<build number>.<revision>
Major version— The component owner usually assigns this number. It should be the internal version of the product. It rarely changes during the development cycle of a product release.
Minor version— The component owner usually assigns this number. It is normally used when an incremental release of the product is planned instead of a full feature upgrade. It rarely changes during the development cycle of a product release.
Build number— The build team usually assigns this number based on the build that the file was generated with. It changes with every build of the code.
Revision— The build team usually assigns this number. It can have several meanings: bug number, build number of an older file being replaced, or service pack number. It rarely changes. This number is used mostly when servicing the file for an external release.
Each build that is released out of the Central Build Lab should have a unique version stamp (also known as the build number). This number should be incremented just before a build is started. Don’t use a date for a build number or mix dates into a version number simply because there are so many date formats out there that it can be difficult to standardize on one. Also, if you have more than one build on a given date, the naming can get tricky. Stick with an n=n+1 build number. For example, if you release build 100 in the morning and rebuild and release your code in the afternoon, the afternoon build should be build 101. If you were to use a date for the build number, say 010105, what would your afternoon build number be? 010105.1? This can get rather confusing.
How Versioning Affects Setup
Have you ever met someone who reformats his machine every six months because “it just crashes less if I do” or it “performs better?” It might sound draconian, but the current state of component versioning and setup makes starting from scratch a likely solution to these performance issues, which are further complicated by spyware.
Most of the problems occur when various pieces of software end up installing components (DLLs and COM components) that are not quite compatible with each other or with the full set of installed products. Just one incorrect or incorrectly installed DLL can make a program flaky or prevent it from starting up. In fact, DLL and component installation is so important that it is a major part of the Windows logo requirement.
If you are involved in your product’s setup, or if you are involved in making decisions about how to update your components (produce new versions), you can do some specific things to minimize DLL hell and get the correct version of your file on the machine.
Installing components correctly is a little tricky, but with these tips, you can install your components in a way that minimizes the chance of breaking other products on your own.
Install the Correct Version of a Component for the Operating System and Locale
If you have operating system (OS)-specific components, make sure your setup program(s) check which OS you are using and install only the correct components. Also, you cannot give two components the same name and install them in the same directory. If you do, you overwrite the component on the second install on a dual-boot system. Note that the logo requirements recommend that you avoid installing different OS files if possible. Related to this problem is the problem caused when you install the wrong component or typelib for the locale in use, such as installing a U.S. English component on a German machine. This causes messages, labels, menus, and automation method names to be displayed in the wrong language.
Write Components to the Right Places
Avoid copying components to a system directory. An exception to this is if you are updating a system component. For that, you must use an update program provided by the group within Microsoft that maintains the component.
In general, you should copy components to the same directory that you copy the EXE. If you share components between applications, establish a shared components directory. However, it is not recommended that you share components between applications. The risks outweigh the benefits of reduced disk space consumption.
Do Not Install Older Components Over Newer Ones
Sometimes, the setup writer might not properly check the version of an installed component when deciding whether to overwrite the component or skip it. The result can be that an older version of the component is written over a newer version. Your product runs fine, but anything that depends on new features of the newer component fails. Furthermore, your product gets a reputation for breaking other products. We address the issue of whether it makes sense to overwrite components at all. But if you do overwrite them, you don’t want to overwrite a newer version.
“Copy on Reboot” If Component Is in Use
Another common mistake is to avoid dealing with the fact that you cannot overwrite a component that is in use. Instead, you have to set up the file to copy on reboot. Note that if one component is in use, you probably should set up all the components to copy on reboot. If you don’t, and if the user doesn’t reboot promptly, your new components could be mixed with the old ones.
Register Components Correctly; Take Security into Account
Sometimes setups don’t properly register COM components correctly, including the proxy and stub. Note that Windows CE requires that you also register DLLs. Note, too, that when installing DCOM components, you must be vigilant about permissions and security.
Copy Any Component That You Overwrite
It is smart to make a copy of any component that you overwrite before you overwrite it. You won’t want to put it back when you uninstall unless you’re sure that no product installed after yours will need the newer component—a difficult prediction! But by storing the component in a safe place, you make it possible for the user to fix his system if it turns out that the component you installed breaks it. You can let users know about this in the troubleshooting section of your documentation, the README file, or on your Web site. Doing this might not save a call to support, but it does at least make the problem solvable. If the component is not in use, you can move it rather than copying it. Moving is a much faster operation.
Redistribute a Self-Extracting EXE Rather Than Raw Components
If your component is redistributed by others (for instance, your component is distributed with several different products, especially third-party products), it is wise to provide a self-extracting EXE that sets up your component correctly. Make this EXE the only way that you distribute your component. (Such an EXE is also an ideal distribution package for the Web.) If you just distribute raw components, you have to rely on those who redistribute your components to get the setup just right. As we have seen, this is pretty easy to mess up.
Your EXE should support command-line switches for running silently (without a UI) and to force overwriting, even of newer components, so that product support can step users through overwriting if a problem arises.
If you need to update core components that are provided by other groups, use only the EXE that is provided by that group.
Test Setup on Real-World Systems
If you’re not careful, you can install all your setup testing on systems that already happen to have the right components installed and the right registry entries made. Be sure to test on raw systems, on all operating systems, and with popular configurations and third-party software already installed. Also, test other products to make sure they still work after you install your components.
The practices and procedures for administering source code, producing software development builds, controlling change, and managing software configurations. Specifically, Software Configuration Management ensures the integrity, reliability and reproducibility of developing software products from conception to release.
I should say CM in Pakistan has been catching up slow but very steadily. There are not many senior people in Pakistan who have dedicated their careers in Configuration Management. Many people moved on to various management roles out of CM after some years of experience. This is due to lack of management opportunities in this area. But, times have changed for good and are getting better. With the growing maturity of CM across the industry, organizations are giving utmost importance to this area and so are hiring people at very senior levels.
I have around 3 years of experience while Interacting CM Professionals internationally and national level; found very strong maturity and awareness. With my experience, I would say Pakistan IT firms still need a broader thinking from CM perspective. In many organizations, people think that CM is just about making builds and controlling source code for projects. We need to educate people about the real importance of Software Configuration Management in any organization. There is a need of clear understanding of various aspects of Configuration Management like Change Management, Incident/Problem Management, Build & release management, Code control/version control , Automated Build management , Parallel development and Continuous integration , Introduction to new tools for software and hardware configurations etc…
CM is much beyond a tool administration or builds management. It does comprise entire life cycle of a project as well as the POST PRODUCTION analysis to improve the process for upcoming projects. It’s a continuous process which not only gives any IT organization a process to boost confidence in delivering quality product with stable code line.
NetSol is vigilant and moving superbly toward innovation and automation through R&D in the field of Configuration Management. Being the CMMI 5 organization; we have implemented excellent Release Management Process that beautifully interacting and entertaining CM Services throughout the organization. We are in process of experimenting Modern tools and discovering best practices for making our process incredibly easy and technically strong. NetSol’s Department of Configuration Management really welcomes newly born organizations and specially those (existing) who want to setup/improve their Configuration Management process and looking for technical improvement mentor; please come up and Consult NetSol with trust.
scmGalaxy is a community initiatives based on Software configuration management that helps community members to optimize their software development process, Software Development Life Cycle optimization, Agile Methodologies and improve productivity across all aspects of Java development, including Build Scripts, Testing, Issue Tracking, Continuous Integration, Code Quality and more!
scmGalaxy is a community initiatives based on Software configuration management that helps community members to optimize their software development process, Software Development Life Cycle optimization, Agile Methodologies and improve productivity across all aspects of Java development, including Build Scripts, Testing, Issue Tracking, Continuous Integration, Code Quality and more. scmGalaxy group that helps organisations optimize their software development process. We provide consulting, training and mentoring services in Agile Development Practices such as Version Management, Continuous Integration, Build Management, Test-Driven Development, Acceptance-Test Driven Development, Build Automation, Code Quality Practices and Automated Testing.
We provide job oriented training in the area of Configuration management, Build and Release Engineering. Candidates with engineering or software background and looking to either start or change their career to Build and Release Engineering, would benefit most from this training. Instructor-led training course offered in India, Bangalore, Delhi, Pune, Mumbai and Hydrabad. Instructor is an expert in Software configuration management, Build and release engineering with more than 15 years industry experience in india.The Goal of the course make the training attendants equip with all the concepts of build and release engineering.
To bring your team up to speed with agile development, We can also run the from Continuous Integration to Continuous Delivery with autoamted course within your premises.
This course is an intensive 1-day & 2-day workshop with a mixture of teaching and lab exercises. Currently, this course is offered exclusively as an on-site course. Please contact us for more details.
This is a hands-on, practical course designed to teach specialised skills for real-world development situations. It is thus primarily aimed at a SCM Engineer, Build/Release Engineer and developer audience.
The course is modular and flexible – depending on specific student needs and requests. Through our trainings, you benefit from the wide experience and architectural expertise of our team. We bring that experience to you in an highly interactive, intensely hands-on setting.
We assume participants have a reasonable understanding of Development in any language as well as a basic understanding of the Software Development Life Cycle.
All our courses are above all practical in nature. We believe that the best way to learn is by doing. So the course contains approximately 80% lab work.
Each registrant will receive a copy of the student notes and lab solutions, a certificate of completion, and a CD containing all the tools covered in the course and CD containing all the tools covered in the course.
This course is provided on-site, and can be tailored to your particular requirements. If you would like our trainings delivered at your premises, or for any additional information please contact us. Please email us at info@scmGalaxy.com
Authors and Contributors
Rajesh Kumar, India (Bangalore), over 8 years of extensive experience in SCM domain having depth knowledge of Configuration Management, Build Management, Packaging, Release Management and Application Maintenance. Expertise in Wide range of CM tools (Perforce, MKS, CVS and SVN(Subversion) and VSS), packaging tools (Wise Studio/InstallAnywhere) and Build Management (Ant, CruiseControl, Anthillpro, Maven, Bamboo, Hudson & OpenMake) and Quality related tools like (Sonar, PMD, CheckStyle, Clover and FindBugs). He writes blogs on http://www.scmGalaxy.com
His primary areas of involvement are in object-oriented development, agile methods, enterprise application architecture, Workflow Management System and Automated Build and Release, Continuous Integration, Build Automation, Test-Driven Development and Code Quality, using open source tools such as Maven, Hudson, and Nexus. Environment.
Praveen Marakkoor, Praveen currently working as Sr SCM Engineer for Blue Shield of California San Francisco,CA USA previously he held Development and SCM positions at Kyocera Wireless,24 Hour Fitness, Experience, Macys, Cisco and Intuit. He has extensive experience in Software Configuration Management and Release Engineering and its tools like Maven,Ant,Perforce,maven, SVN, CVS, Clearcase, PVCS, git, Hudson, Bamboo, perl, shell scripting on heterogeneous environments along with QA Engineering.
Praveen holds a Bachelors Degree in Computer Science and Engineering from Visweswaraya Technological University Belgaum, Karnataka India. Highly detail oriented leadership skilled and a team player. He writes blogs on http://www.scmGalaxy.com
Tushar Patil, Currently working with S1 Services, Pune as Sr SCM Engineer.Having around 8 years extensive experience in Configuration Management and Release Engineering. Expertise in tools like SVN, Ant, Maven, Izpack, Perl, Clover, Shell Scripting, Hudson, Bamboo. Having very good experience in OS installations on Vmware ESX servers(AIX,Red Hat,Solaris) and installtion/configuration/troubleshooting of various softwares like WebSphere ND, Jboss, DB2, Oracle on AIX,Solairs and RedHat operating systems.
Brajesh Kumar Rai, Over 7 years of extensive experience in Configuration Management, Build Management, Release Management and Application Maintenance. Expertise in Wide range of CM tools (Perforce, ClearCase, CVS and SVN), packaging tools (InstallAnywhere) and Build Management (Ant, Maven, Make, CruiseControl, Anthillpro, Electric Cloud, Buildbot) multisite projects. Apart from always I am very adventures ,love any kind of crazy adventure, expert in Rock Climbing and rafting, Loves music gazals preferred. He writes blogs on http://www.scmGalaxy.com
Michael Feighner, USA(San Francisco) Expertise in C/C + +, CMMI, change management, clearcase, clearquest, configuration/data management, database admin, delivery, doors, e-commerce, FORTRAN, GUI, meeting facilitation, MS Excel, MS Word, MS PowerPoint, OOD, perl scripting, process engineering, programming, quality control, requirements, scheduling, shell scripting, sw development, sw installation, sw testing, sql, unix, visual basic, visual studio, vxworks, web site production.
Praveen Thakur, India (Pune) Expertise in InstallShield and Application Packaging Domain. He writes blog on http://www.scmGalaxy.com