Programming category

Canonical currently has a big problem. It needs developers. Its a vicious cycle, developers are needed to improve development, yet to increase the number of developers, we need better development programs.

The sad reality is that whilst Canonical has a wealth of development tools available, they are barely officially supported, out of date, or have no easy way of using them (like systemtap).

We need Canonical to step up and make the development environment for 9.04 a priority, so that first time linux developers, and long time developers have a powerful environment, that is officially supported by Canonical. By improving the development environment to be easy to setup, and more updated, developers are more likely to jump on board. In fact, whilst many developers consider coding on OSX to be a privilage, I have never heard the same said of Ubuntu.

Current areas we are severely lacking include:
- Eclipse is out of date in the repos and has been for ages.. Why?
- Sun and Apple have Dtrace officially supported, with a GUI frontend that really makes things easy. We don't have any support for systemtap nor have we got any comparable profiling gui.
- Windows and OSX has a fully supported out of the box development environment with the most popular languages in 2 clicks. With ubuntu, we have to manually work out which gui's we want, which tools, etc
- Debugging? Ha.. its actually quicker to port the code to OSX and use OSX's development tools in some cases then debug currently, because it supports step-backs and such.
- QT can compete against Cocoa. GTK even with Glade is a joke still. I'm not asking you to fix this, but if you want to encourage GTK development, at least have glade/eclipse integration in a developers metapackage
- Developers centre. Ubuntu has none, so developers aren't given a simple list of changes that might affect them next release, such as the change from Alsa as backend, to Pulse, so we can prepare in time. We don't even have a centralised way of really working together with other ubuntu developers.

Some may say developers can help themselves, but first impressions count. If it takes 3000 clicks to get your development environment to the standard provided by Apple in 5, whilst requiring you to also search for equivilent tools (such as dtrace which are considered standard for many OS's now) by yourself, you certainly wont prioritise the OS. By rewarding developers, with a better development environment, the end result will be a higher quality linux environment.

[....]

Include Aptana in ubuntu repositories.

Aptana is a very powerful web editor based on Eclipse.

http://www.aptana.com/

Supports Ruby, PHP, Python and more.

I am sure you will mark this as duplicate, either way, I think that there are small differences between this idea and similar ones.

First of all, I heard Canonical plans to invest in mainstream, let me say something, mainstream doesn't really need a lot more money than it has now and more work there would just be redundant. I think that if Canonical wants to make a difference, they should put money where it is really needed, there are weaknesses in our Linux OSes.

I think, we need improvements in the development platform, I am the kind of guy that really only needs geany and valgrind to do all his Linux development, however a lot of dev. people have been spoiled by the other parties. There are things like step-back and form designers that these people need. Novell as of now is pushing for Mono to replace native apps, and it is doing it by adding this sort of tools to mono development. I got to say, it would be terrible if developers stopped making native apps and we ended with a half-done OS in which most of the available applications are non-native, we need better tools for native development.

However, please don't focus on doing a monolythical app that does everything and can't be split, instead it would be better to make services that could be used by any IDE that's interested in using them. One part that has issues right now is debugging, in which the command line tools are powerful, but devs from this time are used to GUIs in the debugging world.

So, it would be nice to have some sort of service that could examine a program's execution at the same time it is communicating with an IDE that is using it. So the IDE can use information about the execution flow, contents of arrays, etc, and also the IDE would be able to use break points and step using this server program.

In the form designer area, an open format for GTK form XML files, that are then compiled by an extra app would be nice, well, I am not sure how good Anjuta is on this area so far, still improvements in form design will always be welcome.

Now here is the important section: We need a way to have programming projects compiled directly into .deb packages. Right now there are too many intermediary stages. The best for ubuntu would be to allow making ubuntu deb packages very easily, remember, the easier it is to make these packages the more applications easy to install in ubuntu there will be.

[....]

Unfortunately, many programs using OpenGL actually are using the slow opengl instructions (immediate mode). Immediate mode works by sending instructions to the video card, waiting for them to execute, and then waiting for the results.

They should be using retained mode instead which sends the instructions, and continues doing stuff instead of just leaving the CPU doing nothing. When multithreaded opengl is introduced later, a benefit will only be seen within applications with no sync-points/immediate mode instructions.

Such a tool should be capable of capturing/logging immediate mode instructions being used, the application, and provide an easy way of reporting the dodgy instructions to the developers.

Unfortunately, many developers still aren't aware that immediate mode is a MASSIVE bottleneck, so lets make it easier on them.

For those who aren't coded, this idea allows applications to use the CPU and graphics card more efficiently immediately, and will later provide an exponential increase in speed when technologies like multithreaded opengl are introduced.

For Non coders:
Automated Black box testing basically strongly reduces the chances of things crashing, increases stability, and security. It specifically prevents regressions. I haven't seen any good tools to do this in IDE's.

Eclipse is a cross-platform development tool, that was founded by IBM, MERANT, QNX Software Systems, Rational Software, Red Hat, SuSE, TogetherSoft and Webgain. And is probably the only real competitor against Microsoft's and Apple's solutions.


For Coders:
Black box testing means that you treat a function as a box, and test the bounds of the parameters on it, and a few inside. You don't go and check each line of code. So: int ConvertToDogYears (unsigned int age, char * name), you would test 0,1, a few inside, large numbers, and max ages. In fact, you could also test NULL for name (because regardless if by design it might never receive NULL, it should still test for it).

I propose we make it possible to right click a function in eclipse, and set a few examples of inputs/results and a range to automatically test. This way, if all your functions parameter bounds and a few example tests. Some tests such as passing NULL pointers and seeing if it crashes could be tested too.

This would give us an automated way of testing for regressions, and could also help identify functions which are capable of segfaulting, or which buffer overflow.

The system can also automatically test the maximum values for C type variables, to ensure they are fine, and do tests automatically, such as pass NULL pointers and ensure that the function doesn't try to write to it.

Because if every function cant crash regardless of what is passed to it, it means that we will all benefit. And it means we will have a way for the compiler to test the program for us, and uncover bugs, which might take hackers to uncover (like passing a 3000 character string)

[....]

Idea ;
===

When a program brings up a warning message that says you have to type some text in to the terminal,
then in such cases it would be helpful to have the program just automatically run that script by its self.

There could be a prompt to continue or exit.

The verbose explanation can be available for those who want it.
But if the program knows just what needs to be done, then it would be ideal if it could just go ahead and do it.

Much more convenient for the user. :)


Example situation;
===========

The PC hung, while doing an uninstall using synaptic.
So I hit the reset button.

After rebooting, I started synaptic again.

It came up with the following message ;

"
dpkg was interrupted, you must manually run 'dpkg --configure -a' to correct the problem.
_cache->open() failed, please report.
"

[....]

Ubuntu used to come preinstalled a huge ammount of awful screensavers, and in another hand, it's very difficult to code our own screensavers. A good example about this is shown here: https://launchpad.net/sdlbasic-screensavers

As well, it's hard even to make .swf-based screensavers in a simple and open-source way...

There's roughly 10 million Ubuntu users, if we were to all speak up to companies like Microsoft, Apple, Adobe, and others, we could get versions of their software for our OS.

I would love to get Worldwide Telescope, Microsoft Office, iTunes (that's a big one), Photoshop, and more natively built for our OS, so we can run them without Crossover, or Wine.

Don't get me wrong here, I'm not another idiot whining about not being able to run his programs, I use Crossover and Wine to run a majority of mine, but I'm just saying it would be nice to have some good software.

Python is a really powerful and easy to learn programming language. However, the existing IDEs for Python sometimes are not as user-friendly as they could be. In order to provide a wider choice of IDEs to the programmers, it may be interesting to ask Mono to include Python as one of the languages included in MonoDevelop.

MonoDevelop already includes several languages, so adding one more should not be an issue, and it would enhace the reach of this project.

I know this is somewhat stupid: Enumerate all errors and bugs put out by compilers.
This would it make much more convenient to search bugs in the internet.
Regards

Thanks to Guillermo Gonzalez and his BzrEclipse we can now branch directly from Launchpad within Eclipse.

Next step would be to be able to run bzr-builddeb from within the same environment (Eclipse) - just like we can export to a .jar-file we could export to a .deb.

File -> Export -> General -> Deb File

And perhaps we could even export the package to our Personal Package Archive (PPA) in Launchpad - then it would just be a matter of doing an "sudo apt-get update; sudo apt-get install [my-package]" in order to try out the code on other machines.

I think the hardest issue to solve would be the GPG-signing part as it requires the users attention, cleanest solution would be to make use of Eclipse keystore. See http://wiki.eclipse.org/index.php/Security:_KeyStore_support_for_Eclipse

Then we could kiss the command line goodbye

References:
https://launchpad.net/bzr-eclipse
https://launchpad.net/bzr-builddeb

I follow the Ubuntu development process and keep an eye on https://blueprints.launchpad.net/ubuntu/intrepid

I would love to try out things as they become available but it's hard to get started.

scenario:
Niklas wants to try out the new openldap-cnconfig-migration that is marked as "Beta Available". He clicks "Beta Available" and gets a wikipage (if not directly embedded within Launchpad) with a brief explanation on how to get the package up'n running.

Id love to see a new feature added to Synaptic.. the ability to tell it of various svn repositories, and have it grab the source code.

In addition, when checking for package updates, it would also check these svn repo's and let you know of updates which can be downloaded.

This would be a great way to keep up to date with various tool you want, but arent in the repos.
I wouldnt expect it to have any ability to check source back in, do diffs or anything (well that would be nice, but my idea isnt for a full svn client).

The first step in contributing is getting the source to look at, so it could even encourage more people to get involved in the development.

The following is not really all that specific to Ubuntu, but Ubuntu gets a lot of press, so if there would be an Ubuntu-project for this it would also get the needed press.

A lot of software in the world is custom build software for a specific purpuse or task, for a specific way a certain organisation handles there daily operations.

If we want businesses to use Ubuntu these applications need to be available on Ubuntu.

And a lot of these applications are also very alike, but can not be the same among different organisations. So they need to be custom build.

There are a lot of smaller software companies that build these applications by contract, this can be very expensive.

I think it would be better for companies to post what they want to see developed on a website and have other companies that want to have the same type of application show their interest. If there is enough interest they could go talk to a software development company together or maybe even have software development companies bid for a chance to build these applications.

I personally like to see the developments of platform independant and GPL'd applications and LGPL'd libraries. For example webbased-intranet-applications.

It would not surprise me if something similair exists, but it's not very high profile at the moment ?

It should include a program that puts the system into sleep mode automatically when you close the lid.

The problem with C# and other mono programs, is that the "compiled code" isn't actually compiled at all. It is simplified into bytestreams (so kind of a simplified language) and then interpreted. This is possibly the main reason why Mono applications are much more resource intensive then others, and require more RAM. Because they are also trying to run an entire VM.

I propose that we make it possible for Mono applications to be properly compiled. Possibly with a bit of tweaking, the JIT-code could make a binary instead, eliminating the need for Mono to run in the background, reducing RAM usage significantly, which would speed up linux.

The use of C# ISN'T going to go away. We have to accept this. Many programs are being designed in C# unfortunately, and all we can do is find ways to make C# run faster and more efficiently, to appease the linux crowd.

Pretending mono doesn't exist isn't going to work. Its only a matter of time until some serious killer application is coded with it, and if that happens, we want it to run as fast as possible.

Since GNU Interactive Tools agreed to change name from "git" to "gnuit" we could drop "git-core" and stick with "git"

The project "hello" is a GNU-project thought of as a template for developers - to show them how to create and package a minimal program.

http://www.gnu.org/software/hello/

"hello" is a C-program. I would like to see a version of this program but made in Java. I.e to show developers how to package a source package when using Java.

When use Netbeans and have compiz fusion actived, the netbeans do not show some message, like errors and configuration, i think was very helper fix that, because is a powerful IDE

Hello
I consider anjuta to be too difficult.
But still I wished there where 2 more options
1- When I reange the windows. I want the arrangment to be saved.
2. I program in different languages. And I want different styles for different languages. The problems gets arcut with fe.g. fortran.

Regards