As it currently stands, this question is not a good fit for our Q&A format. We expect answers to be supported by facts, references, or expertise, but this question will likely solicit debate, arguments, polling, or extended discussion. If you feel that this question can be improved and possibly reopened, visit the help center for guidance.
Closed 10 years ago.
Subversion has a superb client on Windows (Tortoise, of course). Everything I've tried on Linux just - well - sucks in comparison....
Disclaimer: A long long time ago I was one of the developers for RabbitVCS (previously known as NautilusSvn).
If you use Nautilus then you might be interested in RabbitVCS (mentioned earlier by Trevor Bramble). It's an unadulterated clone of TortoiseSVN for Nautilus written in Python. While there's still a lot of improvement to be made (especially in the area of performance) some people seem to be quite satisfied with it.
The name is quite fitting for the project, because the story it refers to quite accurately depicts the development pace (meaning long naps). If you do choose to start using RabbitVCS as your version control client, you're probably going to have to get your hands dirty.
Generally I just use the command line for svn, it's the fastest and easiest way to do it to be honest, I'd recommend you try it.
Before you dismiss this, you should probably ask yourself if there is really any feature that you need a GUI for, and whether you would prefer to open up a GUI app and download the files, or just type svn co svn://site-goes-here.org/trunk
You can easily add, remove, move, commit, copy or update files with simple commands given with svn help, so for most users it is more than enough.
To begin with, I will try not to sound flamish here ;)
Sigh.. Why don't people get that file explorer integrated clients is the way to go? It is so much more efficient than opening terminals and typing. Simple math, ~two mouse clicks versus ~10+ key strokes. Though, I must point out that I love command line since I do lot's of administrative work and prefer to automate things as quickly and easy as possible.
Having been spoiled by TortoiseSVN on windows I was amazed by the lack of a tortoisesvn-like integrated client when I moved to ubuntu. For pure programmers an IDE integrated client might be enough but for general purpose use and for say graphics artists or other random office people, the client has to be integrated into the standard file explorer, else most people will not use it, at all, ever.
Some thought's on some clients:
kdesvn,
The client I like the best this far, though there is one huge annoyance compared to TortoiseSVN - you have to enter the special subversion layout mode to get overlays indicating file status. Thus I would not call kdesvn integrated.
NautilusSVN,
looks promising but as of 0.12 release it has performance problems with big repositories. I work with repositories where working copies can contain ~50 000 files at times, which TortoiseSVN handles but NautilusSVN does not. So I hope NautilusSVN will get a new optimized release soon.
RapidSVN is not integrated, but I gave it a try.
It behaved quite weird and crashed a couple of times. It got uninstalled after ~20 minutes..
I really hope the NautilusSVN project will make a new performance optimized release soon.
NaughtySVN seems like it could shape up to be quite nice, but as of now it lacks icon overlays and has not had a release for two years... so I would say NautilusSVN is our only hope.
kdesvn is probably the best you'll find.
Last I checked it may hook in with konqueror, but its been a while, I've moved on to git :)
You could also look at git-svn, which is essentially a git front-end to subversion.
See my question: What is the best subversion client for Linux?
I also agree, GUI clients in linux suck.
I use subeclipse in Eclipse and RapidSVN in gnome.
IMHO there is one great svn gui client, SmartSVN. It is commercial project, but there is foundation version (100% functional) witch can be used free of charge, even for commercial purposes. It is written in java, so it is multi-platform (it requires sun-java* package) http://smartsvn.com
I guess you could have a look at RabbitVCS
RabbitVCS is a set of graphical tools written to provide simple and straightforward access to the version control systems you use. Currently, it is integrated into the Nautilus file manager and only supports Subversion, but our goal is to incorporate other version control systems as well as other file managers.
RabbitVCS is inspired by TortoiseSVN and others.
I'm just about to give it a try... seems promising...
For Ubuntu you cane make use of KDESVN integrated with Nautilus to five a Tortoise SVN Feel.
Try this ClickOffline.com : Ubuntu alternatives for Tortoise SVN
Nobody else has mentioned it and I keep forgetting the name so I'm adding these instructions here for my future self the next time I google it...
currently pagavcs seems to be the best option.
you want one of these .deb files
sillyspamfilter://pagavcs.googlecode.com/svn/repo/pool/main/p/pagavcs/
(1.4.33 is what I have installed right now so try that one if the latest causes problems)
install then run
nautilus -q
to shutdown nautilus, then open up nautilus again and you should be good to go without having to logout/shutdown
Sadly rabbit just chokes on large repos for me so is unusable, paga doesn't slow down browsing but also doesn't seem to try and recourse into directories to see if anything has changed.
I'm very happy with kdesvn - integrates very well with konqueror, much like trortousesvn with windows explorer, and supports most of the functionality of tortoisesvn.
Of course, you'll benefit from this integration, if you use kubunto, and not ubuntu.
Take a look at SVN Work Bench, it's decent but not perfect
sudo apt-get install svn-workbench
I sometimes use kdesvn for work directly against a repository.
I often use Subclipse when working on projects via Eclipse.
But most of all I use good ol' CLI. With some aliases and bash scripts to back it up, it really is the most concise, reliable method of using svn.
I have tried NautilusSVN (no relation to NaughtySVN) and svn-workbench and found them too problematic or lacking in functionality. I know I tried RapidSVN at some point but I must not have been impressed as it was quickly uninstalled, but I don't remember anything about it.
If you use it, NetBeans has superb version control management, with several clients besides SVN.
I'd recommend however that you learn how to use SVN from the command line. CLI is the spirit of Linux :)
If TortoiseSVN is really ingrained you could try using it through WINE? Though I haven't tried it.
Failing that, I've found Eclipse with Subversive to be pretty good.
If you use eclipse, subclipse is the best I've ever used. In my opinion, this should exist as stand-alone as well... Easy to use, linked with the code and the project you have in eclipse... Just perfect for a developer who uses eclipse and wants a gui.
Personally, I prefer the command-line client, both for linux and windows.
Edit: if you use XFCE and its file manager (called Thunar), there's a plugin which works quite well. If I don't want to open the terminal, I just use that one, it has all the functionality, is fast and easy to use. There's also one for git included, though...
Nautilus provides context menu for svn activities
sudo apt-get install nautilus-script-collection-svn
cp -r /usr/share/nautilus-scripts/Subversion ~/.gnome2/nautilus-scripts/
For more info
Nautilus context menu
As a developer, I use eclipse + sub-eclipse client (Assuming that you are using svn to checkout some development project and you will compile them).
most people don't spend much time with svn operation, and command line is the fastest way to do so.
there is also some nice GUI tools :
http://rabbitvcs.org/
or
http://www.harecoded.com/nautilus-subversion-integration-tool-execute-svn-commands-with-gnome-scripts-96355
Since you're using Ubuntu, and not Kubuntu, I assume you're using GNOME. You might be interested in Nautilus Subversion Integration described on that link.
Anjuta has a built in SVN plugin which is integrated with the IDE.
Related
I cannot call myself an absolute beginner in go, and I'm definitively not an expert.
Today, I noticed something VERY confusing. I was experimenting with Unix sockets and Windows named pipes, and from my research, there are 2 packages that support Windows named pipes:
https://github.com/natefinch/npipe
https://github.com/Microsoft/go-winio (I could not find ANY documentation, help, how-to-use, whatsoever about this package)
My OS is Linux, and I decided to give it a go: go get the package(s), and write the code to later test on a Windows machine, but, to my surprise, at least in VSCode, those packages are not recognized by the tooling.
When I look at npipe for example, I see it only has npipe_windows.go, which, if I'm not mistaken, is supposed to automatically be used on Windows.
So, I think there is the concept of OS-specific packages in Go, right? And if so, does it mean that I cannot use, for example, VSCode's go tools to code against Windows packages on Linux?
That, in my opinion, would be extremely inconvenient to have to switch systems in order to write something that works both on Linux and Windows... Although I guess that's only true if we're developing on Linux, and Windows should cover both.
But for me, it doesn't make sense NOT to be able to develop something on Linux; the best environment to develop on IMHO (except Apple-related code of course)
Am I missing something here?
Thank you
So, I think my question actually involves more the tooling rather than the go language itself. gopls is the tool used by VSCode if you choose to use the go language server.
As thre README says, it's in alpha and not stable, and there are known issues listed on the repo, which seem to be the source of my confusions.
I think the main issue that's related to what I'm seeing is:
x/tools/gopls: does not handle build tags
I need your help. Because I've no idea what I'm doing.
There is this nice plugin vim-instant-markdown I recently stumbled onto. Basically, it's a live preview in a browser, running in the background, while you're writing your text in markdown plugin, and I like the concept.
So, I've tried to get it to work on Windows,
installed Ruby (rubyinstaller-1.9.3-p125)
installed Ruby-DevKit (DevKit-tdm-32-4.5.2-20111229-1559-sfx)
followed instructions on https://github.com/oneclick/rubyinstaller/wiki/Development-Kit
gem install redcarpet pygments.rb
installed node (node-v0.6.10)
npm -g install instant-markdown-d
So far so good,
I open a markdown file in Vim, and it opens (pause button works here) a command line window with my text inside. Browser not seen anywhere.
In the plugin there is an /dev/null "thing" (I'm not an unix guy, more than I needed to be, which wasn't very much - just an ordinary user for most part). /dev doesn't exist on Windows.
To put long story short, my question is - can this be made to work on Windows, the way it should work, or is it a waste of effort even to try it to get it to work?
I'm welcoming all constructive ideas and suggestions.
glad you found this useful enough to want a Windows port! I think it definitely can be done, you just might need more dependencies and hackage.
First of all, understand that there's a server component that is used apart from the actual .vim file to make this work, which is started and stopped on demand. You will definitely need to look at its code, which can be found here.
The server uses open on OSX and xdg-open on Linux to open a browser window, neither of which exist on Windows. On Windows, you can use start (more here). Try to find a way to make the browser window open in the background, and not steal focus, otherwise it will be very annoying.
Also, curl is used to send commands to the server, and curl doesn't exist for Windows. Indeed, I don't think anything similar exists. There is a curl Windows port, though IMO it kinda sucks to add such a thing as a requirement for the plugin...
It seems that you've taken this on at least partially as a learning experience, so I hope you can make it work and send back a pull request! (Of course feel free to keep asking questions if you're stuck) But in the (hopefully unlikely) event that you lose interest or give up, create an issue in github requesting Windows compatibility, and I'll see if I have time to implement it. Also, keep in mind that some questions/comments will be better suited to the project's issues area than here.
Good luck!
I have been using a chrome book for a few months now. I also have been designing a web page. A lot of the work can be done via word press's lame gui, but like any coder, I want to use a real text editor, specifically vi/vim.
I have done some searching around. I found one java script implementation of vi, but it's not good enough IMO to use. Conversely, I'd like to ssh into one of my *nix boxes and use vi that way, although you cannot do that from web pages it seems. HTTP vs TCP issues. Not sure if WebSockets will be able to get around this.
Lastly, I've been looking at plugins. While some decent ones seem to be available for Firefox, the Chrome division is lacking severely.
One desparate try is vnc, but this chromebook has no javascrip support, not can I get the HTML5 vnc running quite right.
Does anyone have any suggestions?
Edit/Update:
Thanks for everyone's effort in answering. I quickly abandoned coding on the netbook, but it looks like some great answers were provided.
I am on a Samsung ARM Chromebook and I do a lot of development work in Vim. Here's how I prefer to do it:
Enable Developer Mode, then download crouton.
Open a shell:
<ctrl><alt>t
...and install Ubuntu command-line environment
sudo sh -e crouton -t cli-extra
Enter the chroot using
sudo enter-chroot
From inside the chroot install vim
sudo apt-get install vim
There are lots more instructions and examples on the crouton github page.
I prefer the command line only version because I can just have Ubuntu in another tab, and all the Chromebook keyboard shortcuts Just Work.
You have few options:
Cloud9, an IDE for JavaScript, Python, PHP, and Ruby. Cloud9 uses the HTML5 FileSystem capability and AppCache to sync files, so you can even code offline. It got some really nice features that I find myself using a lot: github integration, chat, the ability to work and do reviews on your code without any pain of ‘new/other’ tools.
Kodingen is an Online Development Environment including Code Editor, Cloud Hosting etc'. I haven’t play with it (yet) – but I’ve heard some friends that like it.
Codey - Easy to use code editor for HTML, PHP, CSS, JS. They are in Chrome web store.
Akshell - Server-side JavaScript development and hosting platform. They got some git integration built in their IDE.
I hope it helps.
For more, I've posted something about this Q few months ago: http://greenido.wordpress.com/2011/07/04/web-developers-and-the-new-chromebook/
There are web shells: this is the first one that came up with a search, but there are others. Be sure to use HTTPS and place it behind a authentication gateway. I can't vouch for how well they handle vim and it's interesting screen modes, but hopefully one of them might work.
How about SourceKit? Unforunately the bindings are closer to textmate, it has great highlighting and IMHO the text will be easier on the eyes than if you were looking at tiny shell font.
I just finished porting an application from Windows into Linux.
I have to create an installer of the application.
The application is not open source => I should distribute the application's binaries (executable file, couple .so files, help files and images).
I found several methods to do it:
- RPM and DEB packages;
- installer in .sh files;
- Autopackage.
I don't like first method (RPM and DEB packages) because I don't want to mantain different packages for different Linux distros.
What is the best way to distribute a binary application for Linux?
Having been through this a couple of times with commercial products, I think the very best answer is to use the native installer for each supported platform. Anything else produces an unpleasant experience for the end-user, and in practice you have to test on every platform you want to support anyway, so it's not really a significant burden to maintain packages for each. The idea that you can create a binary that can "just work" on every platform out there, including some you've never even heard of, just really doesn't work all that well.
My recommendation is that you pick a platform or two to support initially (Red Hat and Ubuntu would be my suggestions) and then let user demand drive the creation of additional installation packages. Perhaps make it known that you're willing to support additional platforms, for a modest fee that covers your time and effort in packaging and testing on that platform. If a platform proves to be very different, you may need to charge more for ongoing support.
Oh, and I cannot overemphasize the value of virtual machines for scenarios like this. You need to build VMs for each platform you support, and perhaps multiple VMs per platform to make it easy to test different configurations.
There were a lot of good answers (mine included :)) here. Although that is more about binary compatibility (which you do need to worry about).
For installer I would recommend autopackage (we successfully released several versions of our software with it), they did the "installer.sh" part already and more (desktop integration for example).
You have to be careful and test your upgrade scenarios and stuff, depending on how complex you package structure is, but it is pretty neat overall. I fixed few bugs with dependency handling in 1.2.6, so it should be fine.
UPDATE: The original question was deleted, so reposting full answer here, ignore all references to autopackage, that was merged into Listaller, not sure if relevant parts survived.
For standard libraries (like crypto++, pthreads, etc) that are likely to be available in a distribution -- link dynamically and tell users to get them from their distro repository. Or link statically if it is feasible.
For weird libraries that you must control version of (if you want to deploy Qt4 app on territory of enemy gnomes for example), compile them yourself and install into a private spot only your app knows about.
Never install private libs into standard places unless you can be sure to not interfere with package systems of all distros you support. (and that they can't interfere with you either).
Use rpath instead of LD_LIBRARY_PATH, and set it properly for all you binaries and all dlls that reference each other. You can set rpath on you binary to "$ORIGIN;$ORIGIN/../lib;/opt/my/private/libs" and have linker search those places before any standard paths. (have to setsome linker flag for origin to work I think). Make sure to set rpath on your libs too: for example QtGui needs QtCore, and if user happens to install standard package with different version, you absolutely don't want it picked up (exe -> ../lib/QtGui.so (4.4.3) -> /usr/local/lib/QtCore.so (4.4.2) -- a sure way to die early).
If you compile with any rpath, you can change it later with chrpath, thus making it possible to tweak install location as part of post processing or install script.
Maintain binary compatibility. GLIB_C is pretty much static for your users, so you should link against some sufficiently old version. 2.3 is a safe bet. You can use APBuild -- a gcc wrapper that enforces GLIB_C version and does few other binary compatibility tricks, so you don't have to compile all you apps on a really old distro.
If you link to anything statically, it generally will have to be rebuilt with APBuild too, otherwise it is bound to drag newer GLIB_C symbols. All .so's you install privately will naturally have to be built with it too. Sometimes you have to patch third party libs to use older symbols. (I had to patch ruby to return real permissions instead of effective ones, since there is no such functions in older GLIB_C. Still not sure if I broke anything :)).
For integration with desktop environments (file associations, mime-types, icons, start menu entries, etc) use xdg-utils. Beware though, like everything on linux they don't really like spaces in filenames :). Make sure to test those things on each target distro -- xdg implementations are riddled with bugs and quirks.
For actual install you can either provide variety of native packages (rpm, deb and a few more), or roll out your own installer, or find installer that works on all distros bypassing native package managers. We successfully used Autopackage (same people who made APbuild) for that.
It's possible to install an RPM on Debian and an APT on RHEL.
If you are going to statically link this program, or dynamically link only with libraries that you will be distributing in the package, then it doesn't much matter how you distribute it. The simplest way is tar.gz and that would work.
OTOH if it is dynamically linked with system libraries, and particularly if it has dependencies on dynamic libraries that will be shared with the client's other applications, then you kind of need to do either RPM, APT, or both.
You may want to try out InstallBuilder. It is crossplatform (runs on Windows, Linux, Mac OS X, Solaris and nearly any other Unix platform out there). It is used by Intel, Motorola, GitHub, MySQL, Nokia/Trolltech and many other companies so you will be in good company :) In addition to binary installers, it can also create cross-distro RPMs and DEB packages.
InstallBuilder is commercial, but we offer free licenses for open source programs and very significant discounts for mISVs or solo-developers, just drop us a line.
Create a .tar.bz2 archive with the binary, then publish a feed for it, like this:
<?xml version="1.0" ?>
<interface uri="http://mysite/myprog.xml"
xmlns="http://zero-install.sourceforge.net/2004/injector/interface">
<name>MyProgram</name>
<summary>what it does</summary>
<description>A longer description goes here.</description>
<implementation main='bin/myprog'
id="sha1new=THEDIGEST"
version='1.0'>
<archive href='http://mysite/myprogram-1.0.tar.bz2'
size='10000'/>
</implementation>
</interface>
Sign it with your GPG key. You can use the tools on 0install.net to calculate the digest and add the GPG signature for you in the correct format.
Then, put it on your web-site at the address in the uri attribute. Any user on most Linux distributions (e.g. Ubuntu, Fedora, Debian, Gentoo, ArchLinux, etc) can then install and run your program with:
0launch http://mysite/myprog.xml
Their system will also check for updates periodically. There are various GUIs for the different desktop environments, but the command-line will work everywhere.
Also look at some of the existing feeds for inspiration.
I tell you an additional possibility, although I am not aware of its status: the Loki installer. Loki was a company doing videogames porting for Linux. It went down in 2002, but the installer is available.
InstallShield is also available for linux. No idea on the status though.
Although many people are proposing you to go with tar.gz, please don't. I assume you want to provide a pleasant experience for the installation procedure to your users. A tar.gz is one of the most low level, low quality, low usability choices you can do. It works everywhere because it does basically nothing, as you know.
The guys at freedesktop.org and the LSB are quite clear on where to put stuff. What you need is a friendly program to do that. Autopackage imho has the numbers (I love it), but despite its age, I haven't seen a single program out there distributed as an autopackage.
Evaluate it carefully, but don't skip the chance of being part of the momentum in favour of it, just because it's not popular. If it works for you, and it works for your users, everything else does not matter.
There is no best way (universally speaking).
tar.gz the binaries, that should work.
Today, I would also look at Snapcraft and Flatpak which are embraced by some popular distributions. I explored other options and it is what ended up working best for me. Flatpak in particular also helped me learn about standard Linux desktop conventions to follow.
You may also want to look at AppImage (https://appimage.org/). The concept is that it produces a single binary file that the user downloads, sets executable, and runs directly; no installation necessary, no dependencies to install (since the app image typically includes all the dependencies except basic stuff like glibc). This makes for a really great user experience!
Some downsides:
The image may be large, since it probably includes all files/libraries/... the app depends on.
As the image creator, you're responsible for security updates to any of the libraries you add into your image.
An AppImage is great for a user-run application that's pretty isolated from anything else on the system (i.e. daemons, system configuration, etc.), but if your app relies on things like udev integration, desktop file installation, dbus registration, etc. this isn't easy, since the apps files aren't available when the app isn't running (making udev rules hard), and there is by definition no installer that gets run (making desktop file installation hard).
I've also looked into this at work and I'd have to agree there really isn't a "best way". If your application is being distributed as source then I'd go with the make/configure methods packaged up in a tar.gz. That seems fairly universal in the Linux world.
A good way to get an idea of what to do is to look at larger organziation and see how they distribute their binaries.
I want to setup a minimal set of cygwin applications (ls, diff, path, find, grep) so that they run on a machine without the full cygwin install.
I am assuming all I need are the *.exe files and *.dll that are relevant. So far, this is what I have. It works so far, but I was wondering if there are any issues down the road that I might experience.
Not really, but you might want to look at UnxUtils, which has some advantages over cygwin for the sort of application you're describing:
It does not depend on an external DLL.
The executables use msvcrt.dll, rather than cygwin.dll so they play nicely with native windows paths. There is no disconnect between the /cygdrive path and the native paths used by the rest of the system.
Because of (2) it integrates much more nicely into command or bat files if you have occasion to have to do this.
UnxUtils is quite good for deploying functionality like sed to windows machines because you can just drop sed.exe into an application directory and not have to worry about registering any DLL's or other installation complexities. CMD.exe will pipe and redirect well enough to use these in batch files, and the utilities do not mind \r\n line terminators.
There is also the GnuWin32 project. I use that and CygWin, so sometimes I have a hard-time telling what kind of environment I'm working in..... not that that's a bad thing!
One issue I can see is licensing. You may need to research under what conditions you are allowed to redistribute binaries. (It may be a simple as including a statement in a README file about where to obtain the source.)
Another issue is Cygwin updates. When new binaries are released, how will you keep end users up to date?
A third potential problem would be configuration files that an application would need. No doubt this would be easy enough to figure out in testing, however.
Have you considered MinGW? It would seem to fit your purposes better than Cygwin.