The new version of VSCode 1.75 contains the new feature Profiles, which can be accessed via [Settings-Wheel]-[profiles].
One can now create profiles with different extensions and switch between them.
It would be great if a workspace would automatically use a specific profile.
Is there any way to bind the profiles to a workspace/working directory so that I can set up a workspace to automatically select a specific profile when I open that workspace?
So far I have not found a way to do this.
As it turns out, VSCode does this already. You just have to follow the correct order:
You select a specific workspace / folder and set your profile there the way you want it to be for that workspace - I take a workspace for C++ and uninstall everything I don't need for C++ development.
Now you can choose another workspace - for example one for Python. I create a new profile (I like to use one based on my base profile where I had everything installed so far) and remove everything from it that I don't need for Python development - for example the C/C++ development tools.
If I now switch back to my C++ workspace, I find all the settings there again as I left them.
The nice thing is that I don't just deactivate extensions as before - I actually uninstall them from the profile.
It makes the Extensions area much cleaner.
Related
The situation is, I want to share my settings of vscode.dev to others. That could include
extensions installed
tabs opened (not files, but some extension related tabs such as panels or previews)
So the person who clicked on the shared link can go to vscode.dev, but with my configurations.
Try to use Settings Sync, its the easiest way: Settings Sync
You could try to create a settings.json too, and share that file with others.
I think the only solutions you have here is to use either GitHub Codespaces (Dev Containers) or store config in repository.
Basically you will not have a link for preconfigured vscode.dev. The idea is to have all required configuration in devcontainer.json file committed it to repository. So whenever the repository is opened VSCode uses the file to configure environment.
Also you can change you settings in Workspace and right click on extensions and click "add to workspace recommendations". That will create .vscode/extensions.json, .vscode/settings.json and commit .vscode folder into repository.
TLDR: commit VSCode configuration files into repository and open repository in vscode.dev
Look into Profiles, which can be enabled in your Settings (currently experimental but will be made generally available in vscode v1.75 due out very soon.
Current setting in Stable: Workbench > Experimental > Settings Profiles: Enabled
There is no setting for Profiles in the Insiders Build, it is just enabled by default. I assume when v1.75 Stable comes out that will also be the case.
See v1.75 Release Notes: Profiles:
We are happy to announce that the Profiles feature is now generally
available in VS Code. A Profile can include extensions, settings,
keyboard shortcuts, UI state, tasks, and user snippets. You can
customize VS Code for different development scenarios like data
science, documentation writing or for multiple programming languages
like Python or Java. If you have different VS Code setups based on
workflow like Work or Demo, you could also save those as different
profiles. You can open multiple workspaces (folders) with different
profiles applied simultaneously.
{image omitted]
You can also export and import profiles to share them with your
colleagues, friends or students to help them get started with VS Code.
The following video demonstrates how to export a profile using a
GitHub gist in order to share it with someone. Users that receive the
profile link can preview the shared profile in VS Code for the Web and
import it to their local VS Code instance.
There is a nice mp4 demonstration in the link, but it appears SO would take that format.
You can export a Profile to a Github Gist so that it can be imported by someone else or to a local file you can share (or yourself to a new maching, etc.) - my demo shows all the settings, UI State and extensions it can include.
More info on Profiles at v1.69 Release Notes: Settings Profiles
i know that the default profile name when i installed websphere was Appsrv01, I want to create my own AppSrv02 but the location of my IBM Websphere was in C: and i dont have any write permission, i dont have any admin rights also..
using COMMAND-LINE, I want to make my profile folder to be writable, so that my newly created AppSrv02 will be list down in the profile names in my RAD.
Please help me. Thanks
So that's your problem. In order to have a usable profile in WAS, your user must have write permissions. See this link from WAS ND infocenter, it applies to WAS standalone too.
http://www.ibm.com/support/knowledgecenter/SSAW57_8.5.5/com.ibm.websphere.installation.nd.doc/ae/tpro_manage_nonroot.html
If you cannot change the write permissions to this profile, you'll need to create your own. For this, you can either use WAS Profile Management Tool, WAS CLI or you can create your profile using the Configure profiles... link in the WAS server creation wizard you posted. I'd use the RAD way because RAD validates, within the IDE, the proper permissions that you need to create and use the profile within RAD.
First check whether you have admin rights or not if your using User/Guest profile, by creating any new folder in C drive where IBM WAS is installed.
If you have Admin rights, than right click on RAD run as administrator. It should work fine.
If Profile doesnt show up in drop down, Configure new profile and try checking that way.
If you dont have Admin rights better install RAD in any local drive other than C
Running Eclipse with Admin rights and removing the read-only tick for the AppServXX folder/WAS folder couldn't help me... cause I copied the WAS server from another PC :). So for those of you who want to move / migrate your development environment:
I did a search inside the copied WAS, Eclipse and the project's workspace folder for their old paths (with Total Commander, feed the results into a list) and dragged all the files (except the log ones) into my editor (NotePad++) and did a replace in all open documents for the new paths. It's a bit lucrative, but it took only 10 minutes for me and afterwards the WAS server in Eclipse showed the correct profile and it also did start up well.
I've recently updated IPython (to 4.0) and have started using Notebooks after a period of some time not using them (since before The Big Split, I think), and have discovered that some of my settings need to be modified and moved from ~/.ipython/ to ~/.jupyter/.
For example, it appears that the NotebookManager.notebook_dir in
~/.ipython/profile_default/ipython_notebook_config.py
is ignored and has had its functionality replaced by FileContentsManager.root_dir in
~/.jupyter/jupyter_notebook_config.py
Beyond isolated incidents like this, however, it's not clear to me how the configuration settings and profiles now work. In particular what files should be located where, and what they should contain. If, for example, I generate a new profile with
ipython profile create foo
I now get different files than I used to (and than those present in my existing profiles): where I used to get
ipython_config
ipython_notebook_config.py
ipython_nbconvert_config.py
I now get
ipython_config.py
ipython_kernel_config.py
and as near as I can tell, none of my ipython_notebook_config.py are used.
This (and the limited documentation) all leaves me a bit confused about where should I place my settings and profiles for use with IPython/Jupyter 4.0, specifically:
Where should I place general notebook-related settings for use by all kernels/profiles? (I see that some go in ~/.jupyter/jupyter_notebook_config.py, but it's not clear to me whether these would override settings loaded from elsewhere.)
Where should I place profile-specific settings for use with notebooks? (Can I continue to use ipython_notebook_config.py files in ~/.ipython/profile_someprofile/ directories?)
Where should I place kernel-specific settings for use by all profiles and applications. (For example, where should settings used by IPython for all profiles in both the shell and notebooks go?)
How should I modify or update existing IPython profiles for use with 4.0.0? (For example, should all have a ipython_kernel_config.py file; should I delete the ipython_notebook_config.py and ipython_nbconvert_config.py files?)
OS X 10.10.4; Xcode 6.4; CLT: 6.4.0.0.1; Clang: 6.1; Python Python 2.7.10 (Homebrew); Jupyter 4.0.4; IPython 4.0.0.
First of all, check what's in your ~/.jupyter/ folder. Some of the comments under the question mention you have a file named "MIGRATED" that contains only a timestamp.
If you are in this state, run the command: jupyter notebook --generate-config which will create a new file ~/.jupyter/jupyter_notebook_config.py. If you already have this file, you don't need to run this command.
This file is where you put the code that will modify your IPython Notebook behavior. It's a fully commented out (and well documented) file.
I have a related question open (How do I get IPython profile behavior from Jupyter 4.x?) that deals with attempting to set up multiple profiles, which is currently unanswered.
My team is taking over a project from a previous team. We use a different TFS server than the original team, and we are also not interested in keeping the history of the project because we are accepting the latest version of the code as the beginning of our history with the project. Branching is not an option since we want to start our history from the current version of the code. We just want a fresh project with the existing code.
I have not been able to create the new project from the old code successfully. I keep getting an error: "Source control cannot add the solution: Solution would span multiple workspaces"
My process for attempting the new project creation:
Create a workspace for the previous team's version of the code.
Get latest version of that code into local mapped workspace directory
Open the solution.
Unbind all projects and solution.
Close solution.
Create a workspace for the new version of the code on our TFS server.
Copy the unbound code on my local box to the new local workspace mapped folder.
Open the solution from the new directory.
"Add to source control" from the new solution.
Then I get the error. I have tried removing the TFS security files out of the code directories in the unbound version and tried changing source control instead of adding to source control (but it just binds back to the original instead of letting me bind to the new).
Is there any other way to do this besides recreating the solution/projects and adding back all the files and references? It doesn't seem like it should be this difficult...
Any advice much appreciated!
Your way should work...there's probably some minor discrepancy in your steps or your initial state that I'm misinterpreting. Rather than debug to death, let's abandon what you've got so far and do this instead:
Fetch the previous team's code onto your machine somehow. Preferably just a straight robocopy from a colleague or the old build server; no TFS connections. If you do have any workspaces associated with the old TFS, delete them now.
Unplug from the network, or otherwise ensure the old TFS is not reachable.
Open the solution.
You'll be prompted: "work offline" or "permanently remove bindings"? Choose the latter.
File -> Save All.
Reconnect to the network.
Create a workspace that maps a superset of the code dirs to some path on the new TFS.
Solution Explorer -> rightclick root node -> "Add to source control."
Per the rules I describe on my blog, step 8 should succeed w/o user intervention (no "browse for folder" dialog, no error popups).
Note: steps 2-4 assume you have VS 2008. If you have 2005 you'll have to manually poke around in the Bind dialog.
I'm collaborating on an iPhone application, with the project files (.xcodeproj directory) checked into source control. One important setting is the "Code Signing Identity", which specifies the certificates to use to sign the application in order that it can run on the iPhone.
Each developer on the project has his own Code Signing Identity, so whenever anyone makes a change to the project, his Code Signing Identity gets saved into the project settings, and then everyone else inherits that change. They then have to change that to their CSI before they can continue.
Is there a way to have the Code Signing Identity saved in some local per-user project file that doesn't get checked into source control?
You could base the Xcode project on an .xcconfig file, then make each developer use their own .xcconfig file and keep the identity setting in there.
Either that or have your source control system ignore the file that contains the signature, in git you can create a file called .gitignore, theres probably a similar thing for what you are using. It means even though you've changed it the change won't get mirrored.
I worked around this by making different builds. The one named "Dev - Rob" had my settings in it, and the one named "Dev - [Other Guy's Name]" had Other Guy's settings.
We also used this to make builds like "Release - Beta" and "Release - AppStore" etc., for all situations where we'd have different signing configurations.