Developers: request for complaints
by havoc
I’m looking for a new personal weekend project that would be useful to others. Maybe there’s a useful book or useful piece of software I could create for fellow developers, tech leads, project managers, etc. Doesn’t have to be anything related to any of my current or past work (Linux, C, GTK+, Scala, etc.), but it could be.
Here’s how you can help: complain in the comments (or in private email or on Twitter), about an aggravation, anxiety, ignorance, or unsolved problem that you encounter as part of your work. Where are you wasting time or being kept up nights?
“+1” comments are awesome because if something annoys a bunch of people that makes it more worthwhile to try to solve.
This is once-in-a-lifetime: I’m going to appreciate hearing you complain, and also appreciate “+1” comments! Nobody else is going to do that for you.
I’m not asking for project ideas directly (though if you have them great), I’m just looking for crap you put up with that you wish someone would do something about, problems you had that you couldn’t find a solution to, topics you wanted to learn about that appeared to be undocumented, whatever.
No need to be original; obvious problems are great, as long as it’s still an unsolved problem for you, I don’t care whether it’s obvious, or how many people have already tried to solve it.
No need to have a solution, some of the most important problems are hard to solve, I’m just wondering what’s at the top of your list of sure wish someone would figure out this problem.
Some examples to get you started, if these resonate you could “+1”, but just as good is to come up with more:
- Wish you knew more about <some topic>? Tell me which and maybe I could research it for everyone and report back.
- Anything about your bug tracking, sprint planning, etc. that is tedious, ineffective, or broken?
- Baffled by how to handle trademarks, copyrights, and patents in your projects?
- Unhappy with how your team communicates?
- Are there any software tools you’ve looked for only to say “all the choices suck”?
- Wish you could write your own window manager, if only you had esoteric and rapidly-obsoleting X11 skills? (j/k … right?)
I don’t promise to solve everyone’s problems, but maybe I can solve one real-world actual problem and that would be cool.
Who knows — if we gather enough data someone other than me might run with some of these problems too. Or your fellow commenters might point you to a good existing solution. So let us know what you’re having trouble with.
Thanks!
How about writing about marketing, both strategy and promotion, for open source projects?
Anyone have thoughts on existing stuff they’ve read about how to start/run/market an open source project? There are a few books and posts out there, but I don’t know if they answer all the questions people have, are up to date, etc. What are some burning questions a book like this might talk about?
What’s the point of GObject ? It is justified its existence ? If so, how to use it ?
It’s an object system for C. It’s existence is justified by the fact that C doesn’t have a language-level facility for inheritance, which is an extremely useful thing to have in GUI programming.
Adding this features to C as a library instead of using something like C++ or Java is justified by the fact that using C makes it considerably easier to write binding to many other languages. Oh, and also because C++ and Java are shitty languages of course.
There is a great photoworkflow tool called Darktable, how is that something for you? Well, I think they need some serious usability work. Their collections are not optimal, and their thumbnail view is not so good (scrolling and buffering seems to need work). So even if it is a great tool, they are in real need for some UI / Gnome expertise… and since I know what you have previously done I think you could do a lot for them. And Linux/Gnome really needs a great photography application!
+1
+1 indeed
There’s quite a range of things to do, I reckon. From UI work to new algorithms to parallelisation.
+1. Definitely
Havoc,
Please give us bug tracking as a plugin or feature, integrated into a distributed revision control software like git 😉
I hate that missing step that really connects a commit to a bug fix all in the same location… and I hate that project move thier git repositories from one hosting to another and while the revision history follows, there are many bug tracking databases for any project which moved (not to mention bug tracking usually has to be migrated separately if not by hand, even).
Cheers !
+1
Some attempts http://www.cs.unb.ca/~bremner/blog/posts/git-issue-trackers/
have you tried any of these from Mike’s link? all of them lame? http://www.cs.unb.ca/~bremner/blog/posts/git-issue-trackers/
I’d have this as just one of my many complaints about bug trackers, but don’t know if I’m a freak in that respect.
Please have a look at http://www.fossil-scm.org/index.html/doc/trunk/www/index.wiki
Distributed scm/bugtracker/wiki. Not based on git though.
+1
scalac & sbt are way, way too slow.
+1
structural types in scala are slow and use reflection but would otherewise be awesome (maybe something from JSR292 to the rescuehere? interface injection or use invokedynamic?).
+1
I am pretty sure a good invokedynamic implementation is possible, and could give a x10-x15 speedup
mosh (http://mosh.mit.edu/) is really awesome, but still doesn’t support ssh-agent forwarding or scrollback.
+1
And its GPL license prevents an iOS client.
Good.
That would be awesome on iOS.
And it does not yet support IPv6
+10
distcc for scala
I am still constantly annoyed by apparently experienced programmers who treat complex data structures as strings of text, and try to construct them by concatenating snippets of strings together.
I am clearly not the only one to be suffering from this problem as the top four categories of software security flaw in 2011 were all varieties of injection attack (http://cwe.mitre.org/top25/).
Pick any data structure you like that has a plain-text format as its primary on-disk or over-the-wire representation: HTML, CSS, JSON, XML, SQL, program source code in any language. The chances are that most code that generates data in any of these formats does so by hammering bits of strings together without any concern for properly modelling the underlying data structure.
Common symptoms of this approach are calls to string-encoding functions littering the entire program (not restricted to a data serialization module), and code that is constantly being patched to fix injection attacks and/or double-encoding bugs.
This is especially common in web development, where practically every web framework suffers from this problem. Practically every web framework has some kind of HTML templating language, but very few of them make any attempt to parse the HTML. Programmatically-generated HTML is invariably injected as a string with no error-checking. Templates are littered with calls to various string-encoding functions.
We seem to have mostly solved this problem for XML. Most experienced programmers now understand that XML should be generated by constructing a DOM and then serializing it, by streaming SAX events to an error-checking SAX serializer, or by some equivalent approach. Almost nobody would try to generate XML using a text templating engine. But those same programmers often don’t seem to understand that they should be using an equivalent approach for other data formats too, which proves that they don’t really get it.
I’m not sure if we need education, libraries, more competent programmers or what, but this is the biggest problem in Computer Science right now as I see it.
Is that the sort of thing you were looking for?
+1″ />
XML and SAX are over-engineered crap. I’ll stick to text snippets, thanks.
In some cases it’s justified, however. Compare a Javascript script written with createElement compared to one constructing HTML strings directly. If I encountered the former in something I had to maintain, I would rewrite it to the latter. I have in fact done so in the past for patches I’ve received. It’s just a lot more readable.
If there’s one thing that Python has taught me it’s that static type building and checking in some cases have small benefits and huge downsides.
While you are right in principle, it should not necessarily need to be either-or, but the right solution might be a third path: something readable and easy to write that generates the HTML.
I do understand where you’re coming from though, my take, as a programmer, is that we usually spend much more time reading code than writing it, if we maintain the code (which we should) and it must be easily understood what the output is. createElement is not very good for that…
The fix seems simple enough (E gets this right): allow custom langauge-specifiy interpolation rules.
e.g.
println(`x = $x`)
return xml`$name`
sql`UPDATE users SET name=$name WHERE id=$id`
The parser expands these to e.g.
sql__quasiParser.valueMaker(“$”, [6]).substitute([name])
The quasi-parser parses the *template* (into an SQL prepared statement) then inserts the values later. Writing an SQL injection attack with this syntax is basically impossible. Can we get this into all languages?
http://www.erights.org/elang/grammar/quasi-overview.html
(the E wiki is more up-to-date, but down at the moment)
Comment system stripped the XML tags, so see the link instead. The ` was a backtick/grave when I typed it. The SQL example should have been:
sql`UPDATE users SET name=$name WHERE id=$id`
becomes
sql__quasiParser.valueMaker(“UPDATE users SET name=$ WHERE id=$‘”, [22,33]).substitute([name,id])
(where 22 and 33 are the character offsets of the $-holes)
To define a new interpolation, just create a new object with the right name.
http://www.cmake.org/Bug/view.php?id=8438
“Missing” cmake feature:
In CMake, one can specify dependencies between “build targets”, so that they are built in the correct order (if that is needed).
This works well for the usual user defined build targets present in a CMake-based build system.
However, CMake also provides with some “built in” build targets that are always present in a CMake based build system. These are: “all”, “install”, “test” etc.
The problem: It is not possible to involve any of these built-in targets when specifying dependencies between build targets.
I would like to be able to specify such dependencies.
Example use-case: We have a large test-suite for testing the *installed* software (i.e. not just “built”, but “installed”). So, when the developer invokes the “test”-target, the software should automatically first be *rebuilt* (if needed) and then *re-installed* (if needed).
This is currently not possible to achieve, since (again) one can not specify build-dependencies between CMake built-in build targets.
Simple fix no doubt 🙂
Have you looked at gyp? It’s what Google uses to build Chrome (among other things) across all its platforms. It seems promising.
http://code.google.com/p/gyp/
Aren’t they switching to CMake/ninja?
The android app permission model annoys me to know end. The only application that I need to know my location is google maps. The only applications I use that need internet access are a browser, an email reader, and a podcast downloader.
I would like to selectively white list permissions on a per app basis, so that non permitted requests would fail returning an error or faked results, e.g. a location in the middle of an ocean.
There are a number of apps that allow you to do that, but it requires a rooted device (which isn’t such a big deal). For example :
https://play.google.com/store/apps/details?id=com.stericson.permissions&hl=fr
Cyanogen Mod has a feature for this.
I’d love a web-based hosted IDE for Android, a bit like cloud9, which builds on the server, then sends an apk to my phone, or runs the emulator on a remote server and outputs in an HTML canvas, like VMware’s WSX.
Somewhat related, a webservice which does continuous integration for Android, including running automated UI tests on a wide variety of devices or emulated devices.
I’d give a lot of my company’s money for these 😉
can you elaborate on why a hosted IDE would be good for you? (I’ve wanted one myself but curious if we have the same reasons)
for a CI server is the main goal testing on tons of devices or that existing CI stuff can’t do android? I haven’t done any android dev so I don’t know the obvious.
are there any UI test frameworks people use for android or is that an unsolved problem in itself?
interesting area!
any thoughts from other android hackers?
A web-based IDE would be nice because:
. making it easy to pick up at home what I left off at work, without having to push/pull to a WIP branch
. collaborative editing
. no setup / install
. get rid of the last non-browser program I use
. possibly better integration with the review tools / SCM (it’d be nice to see the review comments in the IDE directly)
A hosted emulator would be nice because the android emulator is very CPU intensive (when emulating ARM especially, but even with x86 + KVM). It’s the only reason why I still need a big-ass machine for work. Maybe you could have a farm of moderately cheap ARM machines running android natively.
The CI stuff is similar, if you want to run unit tests continuously you need to run the android emulator on your build machine, so you need a powerful machine. And having it to run the tests while emulating a bunch of different android versions / devices takes a lot of configuration and fiddling.
There are a few UI testing frameworks for Android, I’ve played with robotium which seems to be the most common. I’ve found the main limitation is that it works well for testing individual activities (screens) separately, but is not very reliable when testing the application as a whole. But that’s a limitation of the android built-in instrumentation framework on which it relies.
+1 for a webservice that does CI for Android.
Web services that do CI and UI tests across Android devices would be valuable to all organizations that do Android development. I think this is a wide-open market opportunity since it is a struggle to develop for so many different devices.
Testdroid already does automated testing on variety of android devices and it’s a webservice: http://testdroid.com
+1 for the testing service.
Mozilla is actually building a system like this right now because nobody else has it.
https://wiki.mozilla.org/Auto-tools/Projects/AutoPhone
Creating application UIs w/ gtk feels way too difficult. Recently I was writing a python app that does all sort of complex interactions with mail servers and mail encodings, and it was all super easy until I tried to create a UI.
I want to develop applications with slick & sliding UIs and right now its easier to do in html/css/javascript then w/ gtk.
(In fact, my current implementation uses a python web server spitting out the UI to a webkit frame – which is terrible, but was easier for me to get it running and looking like I wanted)
So ideally I’d like old-school VB/Delphi style development w/ python + Gtk/clutter.
I believe the way Gnome 3 divides menus into global (application wide) and local (for specific windows) is deeply flawed and confusing. By having menus dispersed between two locations, it is difficult for new users (or experienced ones) to discover functionality and remember where to look. I do not know exactly how to resolve this, but I have seen mockups of so-called “super menus.” I believe all menus should be aggregated into one location, preferably activated by an in-window widget, not removed on the top bar.
Thank you.
Nice idea, sysadmin here:
* (Near) Perfect “office” (word/excel) support so that my users can switch off of word/macosx to libreoffice/linux and interchange with others without their documents looking at all different.
* gnome-terminal should suck in some extra features to make it more awesome.
* systemd should shove their mess of /tmp/systemd-namespace-XXXXXX folders into one big /tmp/systemd-namespace/ folder.
* GTK should kick QT’s ass more.
* Someone should figure out (or teach me) how to exec in a one-liner: ssh->screen->sudo->command $args
* There should be standard free software utilities for monitoring/configuring hardware RAID devices in linux that don’t suck.
* There should be standard free software utilities for setting up/configuring system bios’es so you don’t have to do this one at a time manually. maybe getting coreboot supported everywhere is a first step.
HTH, please feel free to email me 🙂
* gnome-terminal has all the features it needs. If you can’t actually think of a feature, then you don’t have a valid feature request. Featuritis is a disease.
* GTK does kick QT’s ass
* Hardware RAID sucks full stop. Use software RAID. It’s portable and it means you don’t have to depend on some jerk hardware vendor.
* Coreboot could make the last request possible. Doing it on OEM BIOS would be like pulling teeth.
* gnome-terminal: I agree, one that comes to mind is the nifty “screen” integration that everyone talks about but never does.
* would love to use software raid 6 for large sets, but it doesn’t keep up in performance against hardware raid 🙁
* software raid is still missing a number of key features too, like proper sgpio for drive identification. i’m not sure why this isn’t possible yet. maybe it is and i’m too ignorant 🙁
* hardware raid is still the only way you can easily have a redundant raid 1 efi boot drive.
hopefully i’m wrong about all these comments, please correct me 🙂
… and lastly, I forgot sorry: evolution should support _storing_ *all* mail (composed sent email and received mail) with pgp. This will make my data more secure even when I’m using a semi-trusted imap server. This is very possible, but no MUA’s seem to support this.
Thanks!
This script encrypts incoming mail: http://oss.tiggerswelt.net/pgpmail.php
This article explains how the hoster did it (German though..) http://wohnzimmerhostblogger.de/archives/1514-IMAP-Inbox-mit-GnuPG-oder-SMIME-verschluesseln.html
I really like gnome 3, except that the grouping of windows by application is a bad abstraction, and a constant source of frustration. Symptoms: typing an application name in the overview and hitting enter doesn’t open a new window. alt-tab doesn’t let me switch between windows of the same application (yes, I know about alt-`. I don’t understand the mental model that I’m supposed to have).
Here’s my wishlist of how it should work. Multiple workspaces. Alt-tab rotates windows within workspaces. This is old news. But here’s the new part. Workspaces become persistent resources. I can open and close them; when I close it it saves the state of all of the windows inside. All of my web browser windows and the contents of all of their tabs. All of the documents I have open, in whatever applications they’re open in.
This way desktops correspond to “activities” (like it says in the menu!). I can have an “activity”/desktop for browsing the web, one for working on my thesis, one for playing games (or perhaps one for each game – I usually want to launch minecraft and the minecraft wiki together for example, and have them arranged a certain way across my monitors). The overview is used (as I do now) for managing those activities – mostly launching new apps into a given desktop/activity, and occasionally rearranging the windows within desktops/activities. But I do it once per activity, instead of every time I want to start a new task after I log in.
hate my commute, couldn’t imagine living closer to work or working at a different company.
man do I hate commuting too. I work remote these days but don’t really love it. Still it’s better than a long commute!
great problem to try to solve. two angles I can think of are trying to make the commute less miserable or trying to make working remote less of a compromise. big wide-open areas
to think about there.
Hey, that’s my problem. I have my work stuff on a server which I can access from home (I have a broadband 10/1 Mbit with 30~40 ms latency), but:
– Emacs in a terminal is pretty fast, but sucks because it’s inside a terminal
– Emacs over X11 sucks because X11 sucks with latency
– Emacs over NoMachine nx/X11 was fast, but incredibly buggy
– Tramp in Emacs works with remote files and is awesome, but unfortunately also sucks because of latency
– I recently discovered sshfs which is nice – but after some use it turns out it sucks too because of latency, it’s caching behaviour is just too simplistic I think
What I need should not be more difficult to setup than either Emacs over ssh (i.e. ssh workserver.example.com && emacs) or sshfs (i.e. mkdir workserver && sshfs workserver.example.com: workserver) and not suck with latency.
I don’t mind if the solution would involve installing something bleeding edge like Wayland. But I’d really appreciate it this was just working.
+1
+1
Another useful piece of software I look for and fail to find every once in a while is a TODO list manager. I like the simple philosophy of gtg, but I’d like to be able to put in excuses (e.g. I can only do that task when I’m at home, or I need to finish that other task first, or I can’t start that until I hear back from Bob) so that the top of the list is always the thing that I should be working on.
Of the ones I looked at, thinkingRock was the only one that was designed for this kind of usage, but it was so complicated that I was wary about getting sucked into spending all my time managing my list instead of doing stuff on it.
Oh also, some kind of shared whiteboard – screen sharing over skype sucks! Even better if it works with a tablet and can record the conversation and whiteboard video in real time, and also serialize the final whiteboard to pdf.
I’ve had the same wish. Have you tried any of this stuff? http://shop.skype.com/apps/Desktop-whiteboard-sharing/index.html (I haven’t, just wondering where existing solutions are hitting trouble)
Google hangouts integrate nicely with google docs, so you can draw while you chat.
But of course it would be nice to have an opensource alternative based on webrtc, so you can run on a local server.
Generally better alternatives to Skype, especially HD for everyone etc.
+1
Thanks EVERYONE so far, this is really interesting and helpful stuff.
More more more 😉
The fragmentation of server-side software stacks sucks from a developer and operations standpoint.
On the one hand, things are a lot better than they used to be since you can use HTTP to talk to different services, and there are also RPC systems like Thrift and Protobufs that work across a bunchof different environments.
On the other hand, it’s annoying as hell to be a Python developer and see that some useful piece of infrastructure is written in Ruby, for example. Especially if it’s support infrastructure, you have to make the decision, “is it really worth installing a Ruby stack to host this one small app?”
I’m not really sure what the solution here is. Using app servers that do a good job of supporting multiple environments, like uwsgi? Making it easier to just drop-in-and-run projects?
Having recently incorporated ElasticSearch into a project, it had a pretty great setup as long as you had a JVM installed. Fortunately, that is pretty easy to do on the Mac and in Linux.
Elastic Postgres? Seems like every company that gets to a certain size reinvents a consistent-hashing sharding scheme for MySQL or Postgres. ElasticSearch does an amazing job with this for Lucene. There are clustered systems out there (Riak, for example) but they just seem too immature yet to replace a stable system like Postgres.
have you seen Heroku’s version of Postgres? don’t think you can use it without buying into their app server setup too but their Postgres stuff sounds cool as a model. (to be clear I like their app server setup a lot but it has tradeoffs that don’t always make sense.)
Seems interesting, but focused on how much data you can serve from a cache (memcache, I presume) — I have no sense of how much actual data you can store in it.
It has the same platform problem that so many of these IaaS providers have. We’re using Rackspace cloud servers, so using Heroku or AWS introduces a big network latency penalty, not to mention issues of securing the data over the wire.
Oops, I missed the “1 TB of storage” bullet point for all plans. Pretty nice, but it’s still a hard upper limit that an elastic DB would provide.
I think it would be entirely possible to build this on top of postgres without needing to change the underlying DB.
apt-get for puppet modules
There are tons of random puppet modules out there on github pages, and they’re of terribly varying quality and inconsistent between distributions.
Would be nice if there was a apt-get, pip, or gem-like tool for installing quality recipes, since I can’t be the first person who needs to install a pretty vanilla redis-server 2.4 instance on Ubuntu Lucid.
Everything is broken. Font rendering, GL, Input handling, multiple screens, the list goes on.
Shit sucks. No integrated backup solution, file management sucks, application management sucks, window management sucks, GAH.
Applications are missing. There is nothing to match the Adobe Creative Suite. Evince can’t edit PDFs. Libreoffice looks and works like crap (but that’s steadily improving), blah blah blah.
I cannot recommend GNOME/Linux to anyone who uses their computer for work with a straight face. And that depresses me.
Speaking of font rendering, do you see this?
http://i.imgur.com/4hpDz.png
Wtf? Why is the x-height changing randomly? Why is the spacing so fucked? WTF? 🙁
yeah something about this blog’s theme completely breaks Firefox fonts on Linux. it may be something simple but I haven’t investigated yet.
Web APIs suck. Nobody ever takes into account that consumers of their APIs are going to by sync’ing their data. So, for example, they don’t provide any kind of delta-from-point-X or even list-of-IDs-that-have-been-deleted-since-time-Y. That shit drives me crazy.
There was once again talk abou the HTTP UPDATE verb in HN.
That could work if anybody implemented their service that way, couldn’t it?
We need a better build system. All of the existing ones suck. No need to go into the autotools. Cmake sucks. Scons sucks. Python setuptools is a disaster. Wimpy semi-cross-platform Python homebrews suck. Suck, suck, suck.
(I’m a big git fan, so I think of this as needing “the git of build systems”. Maybe that’s not the best way to sell the idea … Regardless of that whole minefield, I’d say there are strong parallels between current build tools and SVN-era VCSes.)
Make has a lot going for it. A true DAG of dependencies is clearly right. It’s fast and lightweight and the easy things are easy. I think the only problem that couldn’t in theory be solved by Makefile-generating tools is the limitation of only being able to detect changes using modification times of filesystem objects … which is a killer. The lack of native support for recursion certainly makes things a lot more painful. Inability to query the DAG is also pretty bad.
You can imagine writing a really solid, compact, kickass core that handles the DAG fundamentals, but it’s not obvious to me how you implement user-extensible rules in a sane way. On top of all that is the challenge of implementing configure-type checks and cross-platform abstractions. On the latter topic, I think at this point it’s pretty clear that the only sane path is to ignore everything except Linux, OS X, and Windows, but abstracting over those three is still a lot of pain.
Hurrah for this. For cross platform C++, CMake is almost good. Except for its insane and unnecessary minilanguage, and the fact that its defaults somehow manage to be more cumbersome than Make’s. And the insanity of compiling down to N different (terrible) build tools.
‘tup’ (http://gittup.org/tup/) is an interesting start, but it’s a lot more like plumbing than porcelain, in git parlance.
It would also be really nice to maybe see a build tool with strong opinions (that are appropriate for 2012), so you could lay out your files in the way it expects, type ‘build’, and have it work without any configuration. Like it was 2012 or something.
+5. All the build tools I know require the developer to specify dependencies, and getting them wrong means you have to run “make clean” between every build. I should be able to write a makefile that says “do an incremental build…the sources are over there, and put the output here.”
I like the tup idea. It actually reminds me git for some reasons – small, fast (implemented in pure C), based on crazy ideas but when you understood them it looks exactly right and simple.
redo is a really nice build system, it is lacking a cross-platform configuration system but that can be built on top of it.
+1
Something like qbs 🙂
Distributing unit tests across machines. Our test suite has gotten large enough that it’s starting to hamper turnaround time, and this isn’t the first project I’ve worked on that has hit this.
We’re already using Jenkins to distribute automated builds of each changeset to a small cluster of machines, I’d like to similarly distribute unit tests. The nice thing about unit tests is that by nature they are compartmentalized and share little or no state, and so they should be very easy to parallelize across machines. This is a perfect map-reduce task.
At least for Python (nose) there is nothing for this. There is some single-host multiprocessing, though.
When our requirements.txt changes, the resulting tax of recompiling everything due to numpy balloons our build/test time from 3mins to … much longer than 3mins. I don’t want to start bundling compiled virtualenvs.
With respect to distributing builds and unit tests, I’d love to be able to selectively start up infra pieces vs use mock objects depending on which tests I run. I don’t want to have to spin up a test db, search cluster, and task queue to verify that my new template filters render properly.
Best practices/tools/how-to handle geographically distributed teams. You’ve worked on a lot of them, seems like there should be a book about that. (There probably already is?)
A remote employee can never be fully plugged into what’s going on — they’re not there for the after-work gripe sessions, for instance — but I feel like they even miss out on the big stuff too often. How can that be avoided?
+1.
We have a lot of telecommuters. I usually start work at home and go to the office for part of the day. The disconnectedness can be pretty bad.
+1
Once upon a time we tried keeping a video chat session open. Despite bad video and audio, it’s a bit like having a window that connects the offices.
+1
You can write a detailed paper about how memory management works in modern operating systems and processors.
Because, in most of the theoretical OS books I see that Paging is a total operating system construct, where it splits memory into frames and holds pages in them etc. However, when I see some links, I see things like Intel processors having support for paging, protected pages etc. It is all a bit confusing for someone starting off with computer science. May be the textbooks haven’t caught up with the modern advancements. It will be a good document that will help.
One another good topic will be to write about: Memory mapped files. When to use mmap. When not to use them. What are its benefits / drawbacks etc. These topics might sound trivial to you, but will help a lot of people who are beginning. A good start will help them learn.
This whole programming without a full IDE thing. I do it every day, but…
All’s good on the Java front, and even my bread and butter environment Xcode is borderline OK for Objective-C. But step outside an IDE for a new language, and oh man someone thinks Exuberant Ctags is good? GNU GLOBAL (CAPS LOCK YEAH) seems to be more full featured but adding language support by writing a parser in C? That’s a nice yak to shave when starting a new project.
It would be supercool to have a light weight calender, tasklist or email client that us the evolution dataserver as a backend.
+100
A telepathy based application and or framework for community development, group chat, and collaboration.
The communities and development might be improved by development of a good working alternative to xchat, irssi, and so on. A group communication tool that build on the knowledge from group chat and collaboration with traditional IRC clients.
The tool should work as a IRC client, but also extend the functionality for more modern protocols like XMPP. It should facilitate easier and more effective group communication and integration with developers work flow.
It is a pity that the open source community do not use the more modern protocols and technologies more than we do. IRC was great in 1993, but the development has not made much progress.
Something build on the telepathy framework and possibly empathy, but build for technical communication and open source communities. It should be developed in active communication with bot the gnome and KDE telepathy communities.
Some ideas:
Send and receive git requests and patches trough the chat tool
Shared desktop
Give access to shared directories
Send and receive large files
Secured communication
Support for voice and video group chat. Opus, VP8, speex, theora, and so on gives possibilities the community could have used more.
http://telepathy.freedesktop.org/wiki/Telepathy%20and%20other%20Projects
When I worked with the GNOME project, I had a fair mental map of the entire stack; at least enough that I could get around. I went away for a while and when I came back so much had changed. I don’t understand the output of `ps aux` anymore, and that’s maybe no longer the best way to see everything going on. Every now and then someone makes a tetris-like diagram of some part of the stack, but never the whole thing. Usually there’s no detail beyond “Here’s Gtk+. Here’s X. Here’s libc.” Functions, loops, IPC could be shown. Zoom for detail? Nothing in the process tree when the user logs in to a basic GUI session should be left out.
Once a map is made of the current state of some distribution, maps of other distributions and previous states can be made. Put together they can tell a story.
With enough detail–maybe some animation, maybe chatty connections have thicker lines–the map can be an aid to debugging systemic problems. The map could be tied in to profiling tools.
I forget if this blog has a comment preview. This is a very tiny box to write in. I guess I should have written elsewhere and pasted.
+1
The Tetris diagram is intriguing but the only next step after the intrigue is reading pages and pages of generated docs. The docs are fine for a reference manual but they do absolutely nothing to introduce people to the platform.
http://robla.net/2012/platformeng.svg is an example of a diagram made with the Inkscape plugin Sozi — a sort-of-animated SVG. Something like that would be neat.
+1 — maybe use Inkscape + Sozi to make an animated SVG, as in http://robla.net/2012/platformeng.svg ?
A good, free, linux friendly replacement for gotomeeting / webex / teamviewer etc.
Help finish a 1.0 version of:
https://live.gnome.org/ChristianHergert/Builder/
If gnome had a ide like qt-creator then we could have more apps. Support for gnome-shell extensions would also be cool.
+1
A thing that REALLY annoys me when developing is that I have no automated way of testing compatibility with a certain version of GTK+ – well, that is short of building for that version.
I would LOVE a tool that could highlight compatibility issues within my code. Something I could call like this:
gtk-compatibility-checker –version 2.12 ./
Packaging mess… The Debian side doesn’t have a formal way to install per-app packages. The Ruby/Python/Node etc. packaging side is a horrendous retrograde step on Debian’s advantages.
I’d like something that had the best of both, was ubiquitous, and liked by both Debian and Ruby communities
And that works on both server-side Debian/Ubuntu and developers Macs.
The problem with Python/Ruby/Node is that these communities are obsessed with being on the “cutting edge” and mostly have no care in the world for sane versioning and release timing. They also fork and release code bits like rabbits mate, in order to keep up with the latest hipster trends.
look at nixos.org
you can have a bunch of different versions of the same package installed in parallel, with very strict dependencies.
There needs to be a better way to QA Android and iOS apps.
Each session should be screencast, and testers should be able to go back and annotate the video with highlights, drawings, notes, and voiceovers. Then it needs to be easily uploaded to a bug tracker with relevant debug information (logs, device info, etc). You probably need some tie-in with bug trackers to do this well, or maybe an entirely new mobile-app focused bug tracker?
Right now there’s no good way to record/broadcast an Android session, and with iOS you need to AirPlay to something like AirServer or Reflection running on your Mac. At least that you can plug into a VGA output for your crappy videoconference system, or record a video from a session. Still, waaaay too many steps/clicks.
There’s no standard, good, open source Platform as a Service. OpenStack is trying to do it, but nobody I know is using it. We need something to ruthlessly beat Heroku, and to beat AWS as it is now going up from IaaS to PaaS.
Much like WordPress, it’ll need an easy standard hosted version with a beautiful interface and brand, as well as the option of installing the open source one ourselves.
I’d suggest OpenShift, or is that what you meant by OpenStack? (Too many open* names.)
I still think the web login setup is broken. I know that BrowserID is trying to address this, but it’s still a federated system that requires a middleman to verify you on your behalf. I’d like to have the login process driven entirely by my browser, on the client-side. Now that all the browsers have a synchronization system for passwords, it seems like sending a password-equivalent token with Javascript APIs is not really any worse than username/password logins.
It’s too hard to contribute to open source websites.
Installing one and running on your own machine takes ages, and people don’t give patches to it.
The time of cloning the Windows desktop is long passed it… Where are the open source clones of GMail and Flickr?
Wondering round open source conferences, everyone is using this proprietary stuff.
I think there is a core problem that with a desktop app you can fix a bug and get immediate satisfaction, whereas with a website even if the code is open, you can’t.
There have been attempts (Freebase Acre, ScraperWiki, Cloud9IDE) to do things in the cloud-coding space that could help with this, but none have succeeded yet.
If you can endure PHP, RoundCube is open source and comparable to GMail.
All mail clients suck, mutt just sucks less. A non-sucking mail client for the console for those of us who need to deal with tons of mail each day. With non-sucking I mean something like the vim of email clients consisting only of a small core providing basic functionality such as POP3, IMAP, SMTP, mbox, Maildir support and basic UI possibly using ncurses or slang. Then allow for complete scriptability of every part and let a community build awsome plugins/extensions on top of that. I’m sure that would make a *lot* of people very happy, IMHO it’s a major functionality gap, mutt is just not quite flexible enough and lacks scripting, sup or notmuch require local mail storage, alpine is dead and that’s it.
+1.
Evolution, Thunderbird, Claws, etc. all have a bad case of 90’s Microsoft UI syndrome.
Geary looks promising but both Yorba and Elementary are well known vapuorware vendors.
+1
Completely agree with above, but would also like to be able to build custom GUIs on top (something GVim-ish, so that we can see embedded images and such when not using it in the terminal). Ideally, it should have brilliant support for browsing mailing lists.
Second that, it could be easily achieved by separating the gui from the core engine, weechat would be another example where such a design is used. Good threading support is of course a must.
+1 Something like slrn for mail would rock.
Open source feature tracking and planning tool that integrates cleanly above other issue trackers without trying to be the Grand Unified Master Project Control System. If the existing solutions are so bad that people end up just reusing a wiki, we need something better.
And in addition to that, a generic sigoff system that can be used to record ACK/NAKs for things like budgets, release plans, feature lists, etc. This allows for disconnected operation rather than dragging everyone into a meeting.
(This is a small subset of the “people seem unable to conclude business over e-mail or other informal mans without Having A Meeting” problem.)
Many GNOME apps don’t fit on a 1024×600 resolution screen. Many also don’t work fit on 1024×768. Most of the time there’s no real reason why, other than an arbitrary min-width or some nasty status bar with nothing in it.
Some examples apps are Pitivi, GHex, Glade, gitg. I believe most of these projects are aware but lacking interest (“It Works On My Machine™”).
On a related note, most GNOME app developers seem to use fast, high-spec desktop machines, thus making them completely oblivious to how shockingly awful the average GNOME application start time is on “mobile/embedded” hardware.
Handwriting recognition for mathematics. Not from a picture (extremely hard), but from the movement of the pen (certainly simpler) — hand moves in, latex out. 😛
Some sort of way to use a tablet while developing on a laptop. I can imagine using it to zoom in on the static structure of software, and use the main laptop for the serious work.
Another use for the tablet would be for breadcrumbs, to allow you to switch back to things you were working on before, perhaps after a deep dive.
Some inspiration here: http://techcrunch.com/2012/05/27/hey-kids-get-off-my-lawn-the-once-and-future-visual-programming-environment/
Of course one could use it to investigate the dynamic state of an app as well. Even in C it would be a good d-bus visualizer.
A pretty gui for merging two odt files. (Must work with git)
Improve libreoffices conversion of odt-files with equations from odt to doc and from doc to odt.
I’d like my computers (server, desktop, laptop, tablet, phone) to be (almost) completely stateless – just a cache and/or replicated storage provider for all my apps and data.
I love Vim, but it sucks for writing prose. It’s never going to have support for things like variable-width fonts that are desirable for non-programming usage scenarios.
I want a lightweight rich text editor with strong WYSIWYM style management features and a comprehensive programmable key binding system with Vim-like modal editing. I’d also settle for fully programmable bindings in something like LibreOffice or Abiword (yes, I know Abiword has a Vim mode, but it’s awful).
Instant messaging isn’t portable enough. I want to be able to maintain an always-on IM presence on my home server and be able to attach to it from any computer and device.
I should be able to leave my desk, open an app on my phone, and see all of my ongoing conversations with the same exact state that they have on my desktop and everywhere else. It should have an API that supports native desktop/mobile apps, and a web UI that works everywhere else.
Trillian sort of gets close to offering this today with its continuous client functionality, but it’s not self-hosted and their mobile clients are awful. This solution should be open so anybody can build clients.
Solution could possibly be based on Telepathy, but I’d prefer a really slim dependency stack so that it’s easy to run headless in any server environment, such as a home Linux NAS.
+1
Horrible to have to click away notifications on every single machine I regularly use (4, including my phone). Some jabber servers only send messages to the last machine you typed from, even worse.
What annoys me is that we have all these wildy different size screens these days, but no sane approach to dealing with the problem of being able present a usable user interface limited but also making good use of that space available. As a desktop user with a 24″ screen I sometimes feel being at the losing end of it. GNOME3’s activities screen makes no sense on a large screen. Global menu (or whatever it’s called) makes no sense on a large screen. Our new apps are being designed for touchscreen users (even though we don’t really have those) and small screens with maximize-by-default, menubar, toolbar and whatever else hidden or removed. Likewise, owners of small screens can’t even fit basic applications on their screen! Looking at 8, it seems our colleagues at Redmond are failing hard at this too — sacrificing desktops while chasing touchers. Apple I’m not familiar with. I have no suggestions, but we need to solve this, preferrably with minimum fragmentation and rewrites.
I have gotten anxious about these work-related issues:
* Is it okay for me to delay in answering this email, because it doesn’t
seem very urgent?
* Am I backing up thoroughly and reliably and regularly enough?
* Where’s the good self-hosted Git code review app?
* How to get myself to do the things I need to do instead of what looks
most salient? (https://www.beeminder.com/ is working on this admirably.)
Check out https://code.google.com/p/gerrit/
It’s self hosted, and supports users/reviewers to checkout and run patches to actually test/verify that they work.
Make distributions and other stakeholders of free software understand the importance of Wine for games, and devote resources towards the work itself as well as making it work seamlessly for the end user.
This is something that flies under the radar for almost anyone that is not a gamer or has a lot of gamer friends, exactly how important these programs are, and not just the latest, but the big library of games that these people already own and that would be ditched if they would switch.
What people usually don’t think about is that games are not like programs, that we an simply make our own versions of (office, bookkeeping, browsers, editors, whatever).
Games are like documents. Documents that, like word documents opens with word (or our own implementation) opens with the win32 API + directX or what have you. It’s impossible (sheer workload), not to mention insane, to re-implement them all, even if it is possible (and has happened) to do something that read the original data files and use them to recreate the experience.
We’ve, kind of, basically fixed the professional environment, with the exception of some parts of the creative industry (graphics, sound) and then still it depends on who you ask – and given enough devotion, these things can be fixed completely. We can have our own photoshop and reason, if the right people think it’s important enough. We have office, and bookkeeping and everything else, at least to the point where there are only complicated edge cases still left, much like we also have internal web pages needing ActiveX and IE6 to work – the things that probably is not worth it.
We’re also making headway, slowly, in getting the new releases to also come to free OS’s, especially for indie titles, but also some bigger ones. But the thing is, just because games are like documents and not programs, the old ones will not open with the proverbial openoffice, and so does make little impact.
My take is that, fixing the home/hobby users’ – specifically the gamer’s – needs, are the next important step. If gamers can play their old games, they can switch, and then, ond only then, can game makers feel compelled to support the free platforms. It’s my belief that this must come first, not the other way around.
Of course I only have anecdotal evidence to this effect, but maybe the first step of attacking this would be some kind of big survey to see, exactly how many people will not consider another OS with the main or only reason being games. (I do know a lot of people who also refuse OS/X for this reason, but again, anecdotal – and the situation there is a bit better).
So what is the task? Not coding wine to be perfect by yourself, of course. But if you think it has some merit, as a person with some clout, help others see the same. (And the survey would also be a great thing).
It could of course be that this is a market the stakeholders are not very interested in, if so, then it’s a moot point, because what is needed is resources invested. I personally think that everyone should have the possibility to choose a free system (even though the games are closed – again that’s the next next step, and the old ones aren’t gonna change!). I think this is one of the big ones still left.
It was probably a mistake to take some time and think this through, as my idea will get lost in the sea of ideas thrown at you, but I was specifically looking for a problem that:
a) affects me on a regular basis
b) is something I would have a hard time doing myself
c) is something that you have experience with
So, how about working on seamless integration of gnome-terminal (or other) with a terminal muxer (like tmux, or in its byobu flavor), ssh/mosh, and local terminal configuration approaches like teamocil.
Possibly gnome-terminal is the wrong target for this, and maybe something like terminator (which already handles some things for local sessions, like grouping windows into a layout)
Ideally, it should be possible to bring up a terminal layout, with each window connecting to remote tmux sessions, and keeping those connections working.
A list of problems with current ad-hoc solutions and mish-mashes:
– autossh should be a good solution to keep an ssh session alive or restart it, but for some incomprehensible reason the -M option is *mandatory*, and instead of letting 0 be ‘let the tcp stack decide a port’, it turns the monitoring loop off, so hung sessions do not get detected. As a result, nobody can use autossh effectively.
– there is no good solution to integrating X selection/clipboard with tmux copy/paste buffers
– just as irritating, you can’t even select in a logical way when you use a tmux layout with windows side by side. The terminal doesn’t know tmux is inside it, so selecting text across lines also selects lines from the other tmux window.
– no good mouse integration. There are some experimental hooks that allow you to choose a tmux window with the mouse, but they conflict with the copy/paste hooks.
– it would be excellent if the tmux layout was known to the terminal app, so that normal terminal app methods could be used to do things like switch between windows in a layout, switch between layouts, resize the windows in the layout, …
– integration of scrollback – instead of a scrollback for the whole terminal window (which now no longer makes sense given that inside it as tmux layout with multiple session windows), integrate a scrollback per tmux window with the actual GUI scrollbar, automatically sending it into tmux’s copy mode.
– (at least in the config I use with byobu) tmux’s window manipulations feel slow and sluggish; resizing and switching windows in a layout feels like they should be much faster)
– tmux/byobu regularly ends up using a lot of CPU and or RAM, for no apparent reason. Restarting it loses your layout of windows, pages, … Same for restarting the computer. Ideally, a set of remote sessions as grouped in a terminal application window should even survive reboots.
I think a seamless integration for these technologies would be very benificial to web developers, sysadmins, and devops people.
And for them, the real issue is that they typically don’t have the programming skills to a) go this low-level into terminal land and learn about tty’s and emulations and … and b) to be able to integrate these technologies across computers and work out the proper way of communicating this information between them.
+1. Glue together bash/screen/gnome-terminal into one system that lets you log in and instantly flip around to any open shell you’ve got on any machine (using some kind of SSH backend and practical implementation that usually works without leading to insane security or overhead issues). Bonus points for state preservation so you can reliably recover closed shell sessions. (I.e., “Open most recently closed tab” for gnome-terminal.)
While you’re at it, invent a new shell language that’s efficient but without the absurd syntax of Bourne shell. It seems like that should be possible, right?
Write a basic OpenGL window manager tutorial, with mouse and keyboard support in C/C++ (mainly C++).