Walnut Hills, AP Computer Science, 1998-1999

Post Syndicated from Bradley M. Kuhn original http://ebb.org/bkuhn/blog/2007/05/05/walnut-hills-1998.html

I taught AP Computer Science at Walnut Hills High School in Cincinnati,
OH during the 1998-1999 school year.

I taught this course because:

  • They were desperate for a teacher. The rather incompetent
    teacher who was scheduled to teach the course quit (actually,
    frighteningly enough, she got a higher paying and higher ranking job
    in a nearby school system) a few weeks before the school year was to
    start.
  • The environment was GNU/Linux
    using GCC‘s C++
    compiler. I went to the job interview because a mother of someone in
    the class begged me to go, but I was going to walk out as soon as I
    saw I’d have to teach on Microsoft (which I assumed it would be). My
    jaw literally dropped when I saw:
  • The
    students had built their own lab, which even got covered in the
    Cincinnati Post    . I was quite amazed that some of
    the most brilliant high school students I’ve ever seen were assembled
    there in one classroom.

It became quite clear to me that I owed it to these students to teach
the course. They’d discovered Free Software before the boom, and
built their own lab despite the designate CS teacher obviously
knowning a hell of lot less about the field than they did. There
wasn’t a person qualified and available , in my view, in all of
Cincinnati to teach the class. High school teacher wages are
traditionally pathetic. So, I joined the teacher’s union and took
the job.

Doing this work delayed my thesis and graduation from the Master’s
program at University of Cincinnati for yet another year, but it was
worth doing. Even almost a decade later, it ranks in my mind on the
top ten list of great things I’ve done in my life, even despite all
the exciting Free Software work I’ve been involved with in my
positions at the FSF and the Software Freedom Conservancy.

I am exceedingly proud of what my students have accomplished. It’s
clear to me that somehow we assembled an incredibly special group of
Computer Science students; many of them have gone on to make
interesting contributions. I know they didn’t always like that I
brought my Free Software politics into the classroom, but I think we
had a good year, and their excellent results on that AP exam showed
it. Here are a few of my students from that year who have a public
online life:

If you were my student at Walnut Hills and would like a link here, let
me know and I’ll add one.

Walnut Hills, AP Computer Science, 1998-1999

Post Syndicated from Bradley M. Kuhn original http://ebb.org/bkuhn/blog/2007/05/05/walnut-hills-1998.html

I taught AP Computer Science at Walnut Hills High School in Cincinnati,
OH during the 1998-1999 school year.

I taught this course because:

  • They were desperate for a teacher. The rather incompetent
    teacher who was scheduled to teach the course quit (actually,
    frighteningly enough, she got a higher paying and higher ranking job
    in a nearby school system) a few weeks before the school year was to
    start.
  • The environment was GNU/Linux
    using GCC‘s C++
    compiler. I went to the job interview because a mother of someone in
    the class begged me to go, but I was going to walk out as soon as I
    saw I’d have to teach on Microsoft (which I assumed it would be). My
    jaw literally dropped when I saw:
  • The
    students had built their own lab, which even got covered in the
    Cincinnati Post    . I was quite amazed that some of
    the most brilliant high school students I’ve ever seen were assembled
    there in one classroom.

It became quite clear to me that I owed it to these students to teach
the course. They’d discovered Free Software before the boom, and
built their own lab despite the designate CS teacher obviously
knowning a hell of lot less about the field than they did. There
wasn’t a person qualified and available , in my view, in all of
Cincinnati to teach the class. High school teacher wages are
traditionally pathetic. So, I joined the teacher’s union and took
the job.

Doing this work delayed my thesis and graduation from the Master’s
program at University of Cincinnati for yet another year, but it was
worth doing. Even almost a decade later, it ranks in my mind on the
top ten list of great things I’ve done in my life, even despite all
the exciting Free Software work I’ve been involved with in my
positions at the FSF and the Software Freedom Conservancy.

I am exceedingly proud of what my students have accomplished. It’s
clear to me that somehow we assembled an incredibly special group of
Computer Science students; many of them have gone on to make
interesting contributions. I know they didn’t always like that I
brought my Free Software politics into the classroom, but I think we
had a good year, and their excellent results on that AP exam showed
it. Here are a few of my students from that year who have a public
online life:

If you were my student at Walnut Hills and would like a link here, let
me know and I’ll add one.

Walnut Hills, AP Computer Science, 1998-1999

Post Syndicated from Bradley M. Kuhn original http://ebb.org/bkuhn/blog/2007/05/05/walnut-hills-1998.html

I taught AP Computer Science at Walnut Hills High School in Cincinnati,
OH during the 1998-1999 school year.

I taught this course because:

  • They were desperate for a teacher. The rather incompetent
    teacher who was scheduled to teach the course quit (actually,
    frighteningly enough, she got a higher paying and higher ranking job
    in a nearby school system) a few weeks before the school year was to
    start.
  • The environment was GNU/Linux
    using GCC‘s C++
    compiler. I went to the job interview because a mother of someone in
    the class begged me to go, but I was going to walk out as soon as I
    saw I’d have to teach on Microsoft (which I assumed it would be). My
    jaw literally dropped when I saw:
  • The
    students had built their own lab, which even got covered in the
    Cincinnati Post    . I was quite amazed that some of
    the most brilliant high school students I’ve ever seen were assembled
    there in one classroom.

It became quite clear to me that I owed it to these students to teach
the course. They’d discovered Free Software before the boom, and
built their own lab despite the designate CS teacher obviously
knowning a hell of lot less about the field than they did. There
wasn’t a person qualified and available , in my view, in all of
Cincinnati to teach the class. High school teacher wages are
traditionally pathetic. So, I joined the teacher’s union and took
the job.

Doing this work delayed my thesis and graduation from the Master’s
program at University of Cincinnati for yet another year, but it was
worth doing. Even almost a decade later, it ranks in my mind on the
top ten list of great things I’ve done in my life, even despite all
the exciting Free Software work I’ve been involved with in my
positions at the FSF and the Software Freedom Conservancy.

I am exceedingly proud of what my students have accomplished. It’s
clear to me that somehow we assembled an incredibly special group of
Computer Science students; many of them have gone on to make
interesting contributions. I know they didn’t always like that I
brought my Free Software politics into the classroom, but I think we
had a good year, and their excellent results on that AP exam showed
it. Here are a few of my students from that year who have a public
online life:

If you were my student at Walnut Hills and would like a link here, let
me know and I’ll add one.

Walnut Hills, AP Computer Science, 1998-1999

Post Syndicated from Bradley M. Kuhn original http://ebb.org/bkuhn/blog/2007/05/05/walnut-hills-1998.html

I taught AP Computer Science at Walnut Hills High School in Cincinnati,
OH during the 1998-1999 school year.

I taught this course because:

  • They were desperate for a teacher. The rather incompetent
    teacher who was scheduled to teach the course quit (actually,
    frighteningly enough, she got a higher paying and higher ranking job
    in a nearby school system) a few weeks before the school year was to
    start.
  • The environment was GNU/Linux
    using GCC‘s C++
    compiler. I went to the job interview because a mother of someone in
    the class begged me to go, but I was going to walk out as soon as I
    saw I’d have to teach on Microsoft (which I assumed it would be). My
    jaw literally dropped when I saw:
  • The
    students had built their own lab, which even got covered in the
    Cincinnati Post    . I was quite amazed that some of
    the most brilliant high school students I’ve ever seen were assembled
    there in one classroom.

It became quite clear to me that I owed it to these students to teach
the course. They’d discovered Free Software before the boom, and
built their own lab despite the designate CS teacher obviously
knowning a hell of lot less about the field than they did. There
wasn’t a person qualified and available , in my view, in all of
Cincinnati to teach the class. High school teacher wages are
traditionally pathetic. So, I joined the teacher’s union and took
the job.

Doing this work delayed my thesis and graduation from the Master’s
program at University of Cincinnati for yet another year, but it was
worth doing. Even almost a decade later, it ranks in my mind on the
top ten list of great things I’ve done in my life, even despite all
the exciting Free Software work I’ve been involved with in my
positions at the FSF and the Software Freedom Conservancy.

I am exceedingly proud of what my students have accomplished. It’s
clear to me that somehow we assembled an incredibly special group of
Computer Science students; many of them have gone on to make
interesting contributions. I know they didn’t always like that I
brought my Free Software politics into the classroom, but I think we
had a good year, and their excellent results on that AP exam showed
it. Here are a few of my students from that year who have a public
online life:

If you were my student at Walnut Hills and would like a link here, let
me know and I’ll add one.

Walnut Hills, AP Computer Science, 1998-1999

Post Syndicated from Bradley M. Kuhn original http://ebb.org/bkuhn/blog/2007/05/05/walnut-hills-1998.html

I taught AP Computer Science at Walnut Hills High School in Cincinnati,
OH during the 1998-1999 school year.

I taught this course because:

  • They were desperate for a teacher. The rather incompetent
    teacher who was scheduled to teach the course quit (actually,
    frighteningly enough, she got a higher paying and higher ranking job
    in a nearby school system) a few weeks before the school year was to
    start.
  • The environment was GNU/Linux
    using GCC‘s C++
    compiler. I went to the job interview because a mother of someone in
    the class begged me to go, but I was going to walk out as soon as I
    saw I’d have to teach on Microsoft (which I assumed it would be). My
    jaw literally dropped when I saw:
  • The
    students had built their own lab, which even got covered in the
    Cincinnati Post    . I was quite amazed that some of
    the most brilliant high school students I’ve ever seen were assembled
    there in one classroom.

It became quite clear to me that I owed it to these students to teach
the course. They’d discovered Free Software before the boom, and
built their own lab despite the designate CS teacher obviously
knowning a hell of lot less about the field than they did. There
wasn’t a person qualified and available , in my view, in all of
Cincinnati to teach the class. High school teacher wages are
traditionally pathetic. So, I joined the teacher’s union and took
the job.

Doing this work delayed my thesis and graduation from the Master’s
program at University of Cincinnati for yet another year, but it was
worth doing. Even almost a decade later, it ranks in my mind on the
top ten list of great things I’ve done in my life, even despite all
the exciting Free Software work I’ve been involved with in my
positions at the FSF and the Software Freedom Conservancy.

I am exceedingly proud of what my students have accomplished. It’s
clear to me that somehow we assembled an incredibly special group of
Computer Science students; many of them have gone on to make
interesting contributions. I know they didn’t always like that I
brought my Free Software politics into the classroom, but I think we
had a good year, and their excellent results on that AP exam showed
it. Here are a few of my students from that year who have a public
online life:

If you were my student at Walnut Hills and would like a link here, let
me know and I’ll add one.

Walnut Hills, AP Computer Science, 1998-1999

Post Syndicated from Bradley M. Kuhn original http://ebb.org/bkuhn/blog/2007/05/05/walnut-hills-1998.html

I taught AP Computer Science at Walnut Hills High School in Cincinnati,
OH during the 1998-1999 school year.

I taught this course because:

  • They were desperate for a teacher. The rather incompetent
    teacher who was scheduled to teach the course quit (actually,
    frighteningly enough, she got a higher paying and higher ranking job
    in a nearby school system) a few weeks before the school year was to
    start.
  • The environment was GNU/Linux
    using GCC‘s C++
    compiler. I went to the job interview because a mother of someone in
    the class begged me to go, but I was going to walk out as soon as I
    saw I’d have to teach on Microsoft (which I assumed it would be). My
    jaw literally dropped when I saw:
  • The
    students had built their own lab, which even got covered in the
    Cincinnati Post    . I was quite amazed that some of
    the most brilliant high school students I’ve ever seen were assembled
    there in one classroom.

It became quite clear to me that I owed it to these students to teach
the course. They’d discovered Free Software before the boom, and
built their own lab despite the designate CS teacher obviously
knowning a hell of lot less about the field than they did. There
wasn’t a person qualified and available , in my view, in all of
Cincinnati to teach the class. High school teacher wages are
traditionally pathetic. So, I joined the teacher’s union and took
the job.

Doing this work delayed my thesis and graduation from the Master’s
program at University of Cincinnati for yet another year, but it was
worth doing. Even almost a decade later, it ranks in my mind on the
top ten list of great things I’ve done in my life, even despite all
the exciting Free Software work I’ve been involved with in my
positions at the FSF and the Software Freedom Conservancy.

I am exceedingly proud of what my students have accomplished. It’s
clear to me that somehow we assembled an incredibly special group of
Computer Science students; many of them have gone on to make
interesting contributions. I know they didn’t always like that I
brought my Free Software politics into the classroom, but I think we
had a good year, and their excellent results on that AP exam showed
it. Here are a few of my students from that year who have a public
online life:

If you were my student at Walnut Hills and would like a link here, let
me know and I’ll add one.

Walnut Hills, AP Computer Science, 1998-1999

Post Syndicated from Bradley M. Kuhn original http://ebb.org/bkuhn/blog/2007/05/05/walnut-hills-1998.html

I taught AP Computer Science at Walnut Hills High School in Cincinnati,
OH during the 1998-1999 school year.

I taught this course because:

  • They were desperate for a teacher. The rather incompetent
    teacher who was scheduled to teach the course quit (actually,
    frighteningly enough, she got a higher paying and higher ranking job
    in a nearby school system) a few weeks before the school year was to
    start.
  • The environment was GNU/Linux
    using GCC‘s C++
    compiler. I went to the job interview because a mother of someone in
    the class begged me to go, but I was going to walk out as soon as I
    saw I’d have to teach on Microsoft (which I assumed it would be). My
    jaw literally dropped when I saw:
  • The
    students had built their own lab, which even got covered in the
    Cincinnati Post    . I was quite amazed that some of
    the most brilliant high school students I’ve ever seen were assembled
    there in one classroom.

It became quite clear to me that I owed it to these students to teach
the course. They’d discovered Free Software before the boom, and
built their own lab despite the designate CS teacher obviously
knowning a hell of lot less about the field than they did. There
wasn’t a person qualified and available , in my view, in all of
Cincinnati to teach the class. High school teacher wages are
traditionally pathetic. So, I joined the teacher’s union and took
the job.

Doing this work delayed my thesis and graduation from the Master’s
program at University of Cincinnati for yet another year, but it was
worth doing. Even almost a decade later, it ranks in my mind on the
top ten list of great things I’ve done in my life, even despite all
the exciting Free Software work I’ve been involved with in my
positions at the FSF and the Software Freedom Conservancy.

I am exceedingly proud of what my students have accomplished. It’s
clear to me that somehow we assembled an incredibly special group of
Computer Science students; many of them have gone on to make
interesting contributions. I know they didn’t always like that I
brought my Free Software politics into the classroom, but I think we
had a good year, and their excellent results on that AP exam showed
it. Here are a few of my students from that year who have a public
online life:

If you were my student at Walnut Hills and would like a link here, let
me know and I’ll add one.

On Using Hugin

Post Syndicated from Lennart Poettering original https://0pointer.net/blog/photos/hugin.html

On popular request, here are a few suggestions how to make best use of Hugin for stitching your panoramas. You probably should have read some of the tutorials at Hugin’s web site before reading these suggestions.

  • Use manual exposure settings in your camera. On Canon cameras this means
    you should be using the “M” mode. Make sure choose good exposure times and
    aperture so that the entire range you plan to take photos of is well exposed.
    If you don’t know how to use the “M” mode of your camera you probably should
    be reading an introduction into photography now. The reason for setting
    exposure values manually is that you want the same exposing on all photos from
    your settings.
  • Disable automatic white balance mode. You probably should have done that
    anyway. “Semi-automatic” white balance mode is probably OK (i.e. selecting
    the white balance from one of the pre-defined profiles, such as “Daylight”,
    “Cloudy”, …)
  • Also manually set the ISO level. You probably should be doing that anyway.
  • Using autofocus is probably OK.
  • Try not not move around too much while taking the photo series. Hugin doesn’t like that too much. It’s OK to move a little, but you should do all the shots for your panorama from a single point, and not while moving on a circle, line, or even Bezier-line.
  • When doing 360° panoramas it is almost guaranteed (at least in northern
    countries) that you have the sun as back light. That will overexpose the
    panorama in that direction and lower the contrast in the area. To work against
    this, you might want to choose to do your panorama shots at noon in summer when
    sun is in zenith. Gray-scaling the shot and doing some other kind of
    post-processing might be a way to ease this problem.
  • To work against chromatic aberration it is a good idea to use large overlap areas, and doing your shots in “landscape” rather then “portrait” (so that only the center of each image is used in the final image)
  • Running hugin/enblend on an encrypted $HOME (like I do) won’t make you particularly happy.
  • Pass -m 256 to enblend. At least on my machine (with limited RAM and dm-crypt) things are a lot faster that way.
  • Sometimes moving things (e.g. people) show up twice (or even more times) in the resulting panorama. Sometimes that is funny, sometimes it is not. To remove them, open the seperate tif files before feeding them into enblend into Gimp and cut away the things you want to remove from all but one of these images. Then pass that on to enblend.
  • If regardless how many control points you set in Hugin the images just don’t fit together, you should probably run “Optimize Everything” instead of just “Optimize Positions”.
  • When doing your shots, make sure to hold the camera all the time at the same height, to avoid having to cut too much of the image away in the final post-processing. This is sometimes quite difficult, especially if you have images with no clear horizon.
  • Remember that you can set horizontal and vertical lines as control points in Hugin!
    Good for straitening things out and making sure that vertical things are
    actually vertical in the resulting panorama.

My thoughts on the future of Gnome-VFS

Post Syndicated from Lennart Poettering original https://0pointer.net/blog/projects/gnomevfs-future.html

One of the major construction sites in GNOME and all the other free
desktop environments is the VFS abstraction. Recently, there has been
some discussion about developing a replacement DVFS
as replacement for the venerable Gnome-VFS system. Here are my 5 euro
cent on this issue (Yepp, I am not fully up-to-date on the whole DVFS
discussion, but during my flight from HEL to HAM I wrote this up,
without being necesarily too well informed, lacking an Internet
connection. Hence, if you find that I am an uniformed idiot, you’re of
course welcome to flame me!):

First of all, we have to acknowledge that Gnome-VFS never achieved any major
adoption besides some core (not even all) GNOME applications. The reasons are
many, among them: the API wasn’t all fun, using Gnome-VFS added another
dependency to applications, KDE uses a different abstraction (KIO), and many
others. Adoption was suboptimal, and due to that user experience was
suboptimal, too (to say the least).

One of the basic problems of Gnome-VFS is that it is a (somewhat) redundant
abstraction layer over yet another abstraction layer. Gnome-VFS makes available
an API that offers more or less the same functionality as the (most of the
time) underlying POSIX API. The POSIX API is well accepted, relatively
easy-to-use, portable and very well accepted. The same is not true for
Gnome-VFS. Semantics of the translation between Gnome-VFS and POSIX are not
always that clear. Paths understood by Gnome-VFS (URLs) follow a different
model than those of the Linux kernel. Applications which understand Gnome-VFS
can deal with FTP and HTTP resources, while the majority of the applications
which do not link against Gnome-VFS does not understand it. Integration of
Gnome-VFS-speaking and POSIX-speaking applications is difficult and most of the
time only partially implementable.

So, in short: One one side we have that POSIX API which is a file system
abstraction API. And a (kernel-based) virtual file system behind it. And on the other
side we have the Gnome-VFS API which is also a file system abstraction API and
a virtual file system behind it. Hence, why did we decide to standardize on
Gnome-VFS, and not just on POSIX?

The major reason of course is that until recently accessing FTP,
HTTP and other protocol shares through the POSIX API was not doable
without special kernel patches. However, a while ago the FUSE system
has been merged into the Linux kernel and has been made available for
other operating systems as well, among them FreeBSD and MacOS X. This
allows implementing file system drivers in userspace. Currently there
are all kinds of these FUSE based file systems around, FTP and SSHFS
are only two of them. My very own fusedav tool
implements WebDAV for FUSE.

Another (*the* other?) major problem of the POSIX file system API is
its synchronous design. While that is usually not a problem for local
file systems and for high-speed network file systems such as NFS it
becomes a problem for slow network FSs such as HTTP or FTP. Having the
GUI block for various seconds while an application saves its documents
is certainly not user friendly. But, can this be fixed? Yes, definitely, it can!
Firstly, there already is the POSIX AIO interface — which however is
quite unfriendly to use (one reason is its use of Unix signals for
notification of completed IO operations). Secondly, the (Linux) kernel
people are working on a better asynchronous IO API (see the
syslets/fibrils discussion). Unfortunately it will take a while
before that new API will finally be available in upstream
kernels. However, there’s always the third solution: add an
asynchronous API entirely in userspace. This is doable in a clean (and
glib-ified) fashion: have a couple of worker threads which
(synchronously) execute the various POSIX file system functions and
add a nice, asynchronous API that can start and stop these threads,
feed them operations to execute, and so on.

So, what’s the grand solution I propose for the desktop VFS mess? First, kick
Gnome-VFS entirely and don’t replace it. Instead write a small D-Bus-accessible
daemon that organizes a special directory ~/net/. Populate that
directory with subdirectories for all WebDAV, FTP, NFS and SMB shares that can
be found on the local network using both Avahi-based browsing and native SMB
browsing. Now use the Linux automounting interface on top of that directory and
automount the respective share every time someone wants to access it. For
shares that are not announced via Avahi/Samba, add some D-Bus API (and a nice
UI) for adding arbitrary shares. NFS and CIFS/SMB shares are mounted with the
fast, optimized kernel filesystem implementation; WebDAV and FTP on the other
hand are accessed via userspace FUSE-based file systems. The latter should also
integrate with D-BUS in some way, to query the user nicely for access
credentials and suchlike, with gnome-keyring support and everything.

~/net/ itself can — but probably doesn’t need to — be a FUSE
filesystem itself.

A shared library should be made available that will implement a few
remaining things, that are not available in the POSIX file
system API directly:

  • As mentioned, some nice Glib-ish asynchronous POSIX file system
    API wrapper
  • High-level file system operations such as copying, moving,
    deleting (trash!) which show a nice GUI when they are long-running
    operations.
  • An API to translate and setup URL <-> filesystem
    mappings, i.e. something that translates
    ftp://test.local/a/certain/path/ to
    ~/net/ftp:test.local/a/certain/path and vice versa. (and
    probably also to a more user-friendly notation, maybe like “FTP Share
    on test.local    ” or similar). (Needs to communicate with the ~/net/
    handling daemon to setup mappings if required)
  • Meta data extraction. It makes sense to integrate that with
    extended attribute support (EA) in the kernel file system layer, which should be used more often anyway.
  • Explicit mount operations (in contrast to implicit mounts, that
    are done through automounting) (this also needs to communicate with
    the ~/net/ daemon in some way)

Et voilá! Without a lot of new code you get a nice, asynchronous,
modern, well integrated file system, that doesn’t suck. (or at least,
it doesn’t suck as much as other solutions).

Also, this way we can escape the “abstraction trap”. Let’s KDE play
the abstraction game, maybe they’ll grow up eventually and learn that
abstracting abstracted abstraction layers is child’s play.

Yeah, sure, this proposed solution also has a few drawbacks, but be it that way. Here’s a short incomprehensive list:

  • The POSIX file system API sucks for file systems that don’t have “inodes” or that are attached to a specific user sessions. — Yes, sure, but both problems have been overcome by the FUSE project, at least partially.
  • Not that portable — Yes, but FUSE is now available for many systems besides Linux. The automount project is the bigger problem. But all you loose if you would run this proposed system on these (let’s say “legacy”) systems that don’t have FUSE or automounting is access to FTP and WebDAV shares. So what? Local files can still be accessed.
  • Translating between URLs and $HOME/net/ based paths sucks — yepp, it does. But much less than not being able to access FTP/WebDAV shares from some apps but not from others, as we have it right now.
  • Bah, you suck — Yes, I do. On a straw, taking a nip from my caipirinha, right at the moment.

I guess I don’t have to list all the advantages of this solution, do I?

BTW, pumping massive amounts of data through D-Bus sucks anyway.

And no, I am not going to hack on this. Too busy with other stuff.

The plane is now landing in HAM, that shall conclude our small rant.

Update: No, I didn’t get a Caipirinha during my flight. That line I
added in before publishing the blog story, which was when I was drinking my
Caipirinha. In contrast to other people from the Free Software community I don’t
own my own private jet yet, with two stewardesses that might fix me a
Caipirinha.

What I miss in GNOME

Post Syndicated from Lennart Poettering original https://0pointer.net/blog/projects/what-i-miss-in-gnome.html

A while back there has been a lot of noise about the GNOME
“platform” and what GNOME 3.0 should be. Personally — while I
certainly like the progress GNOME makes as a “platform” — I must say
that the platform is already quite good. In my opinion, what is
lacking right now are more the tools and utilities that are shipped
*with* the GNOME platform than the platform itself. More specifically
there are a set of (rather small) tools I am really missing in the standard set of
GNOME tools. So, here’s my wishlist, in case anybody is interested to
know:

<wishlist>

  • A simple, usable VNC/RFB client as counterpart to the VNC server
    vino that has been shipped since early GNOME 2.0 times. Isn’t
    it kind of awkward that we have been shipping a VNC server since ages,
    but no VNC client? What I want is a client (maybe called
    vinagre as a pun on vino) that is more than just a simple frontend to
    xvncviewer, but not necessarily too fancy. Something that
    integrates well into GNOME, i.e. uses D-Bus, gnome-keyring,
    avahi-ui. There seems
    to be a libvncclient library     that might make the implementation of
    this tool easy.
  • I am one of the (apparently not so few) people who run their GNOME
    session with LANG=de_DE and LC_MESSAGES=C, which
    enables german dates and everything else, but uses english
    messages. Right now it’s a PITA to configure GNOME that way. It’s not
    really documented how to do that, AFAIK. The best way to do this I
    found is to edit ~/.gnomerc and set the variables in there. A
    simple capplet which allows setting these environment variables from
    gnome-session would be a much better way to configure
    this. Nothing to fancy again. Just two drop down lists, to choose
    LANG and LC_MESSAGES and maybe a subset of the other
    i18n variables, and possibly G_FILENAME_ENCODING (although I
    might be the only one who still hasn’t switched his $HOME to
    UTF-8)
  • There’s no world clock in GNOME. Sure, there are online tools for
    this, but I am not always online with my laptop.
  • There is no simple tool to take photo snapshots or record short videos
    from webcams. I want to see something like camorama in
    gnome-media. Nothing too fancy again. No filters, no TV
    functionality. Just a small but useful GStreamer frontend.
  • I’d like to see a simple BitTorrent client shipped with GNOME, which is
    integrated well into the rest of GNOME/Epiphany, so that downloading files from
    FTP or HTTP looks exactly like downloading them from Bittorrent.

</wishlist>

Avahi on your N800

Post Syndicated from Lennart Poettering original https://0pointer.net/blog/projects/avahi-n800.html

I’d love to see proper Avahi support in the Nokia N800 (just think of proper
file manager integration of announced WebDAV shares!), but until now Nokia
doesn’t ship Avahi in Maemo. However, there’s now a simple way to install at
least basic Avahi support on the N800. The INdT includes Avahi in their Canola builds. Hence: just install
Canola and your N800 will register itself via mDNS on your network.

In related news: I am happy to see that Avahi has apparently been included in the just announced GNOME Embedded Platform.

Releases, Releases, Releases …

Post Syndicated from Lennart Poettering original https://0pointer.net/blog/projects/releases-releases-releases.html

I have just released new versions of a few of my packages:

Avahi Logo
  1. Avahi 0.6.18: The most interesting change is probably
    the addition of avahi-ui, our new GTK library which implements a
    standard dialog for browsing for Avahi services. A quick (albeit slightly out-of-date)
    introduction into avahi-ui (including screenshots) may be found in this old blog
    story     of mine. If you are a developer of a GNOME application that acts as network
    client in some way, please consider adding support for avahi-ui to your project. Examples where adding support for avahi-ui makes sense are:

    • Mail applications such as Evolution may use it to browse for POP3, POP3S, IMAP, IMAPS and SMTP servers.
    • VNC applications may use it to browse for VNC/RFB servers
    • Database clients such as Glom may use it to browse for PostrgreSQL servers
    • FTP clients may use it to browse for FTP servers
    • RSS readers may use it to browse for local RSS feeds
    • And lots of others

    There are lots of other small and not so small changes in Avahi 0.6.18.

  2. mod_dnssd 0.5: Mostly an update for Apache 2.2
  3. mod_mime_xattr 0.4: dito

Remember the Verbosity (A Brief Note)

Post Syndicated from Bradley M. Kuhn original http://ebb.org/bkuhn/blog/2007/04/17/linux-verbose-build.html

I don’t remember when it happened, but sometime in the past four years,
the Makefiles for the kernel named Linux changed. I can’t remember
exactly, but I do recall sometime “recently” that the
kernel build output stopped looking like what I remember from 1991,
and started looking like this:


CC arch/i386/kernel/semaphore.o
CC arch/i386/kernel/signal.o

This is a heck of a lot easier to read, but there was something cool
about having make display the whole gcc
command lines, like this:


gcc -m32 -Wp,-MD,arch/i386/kernel/.semaphore.o.d -nostdinc -isystem /usr/lib/gcc/i486-linux-gnu/4.0.3/include -D__KERNEL__ -Iinclude -include include/linux/autoconf.h -Wall -Wundef -Wstrict-prototypes -Wno-trigraphs -fno-strict-aliasing -fno-common -ffreestanding -Os -fomit-frame-pointer -pipe -msoft-float -mpreferred-stack-boundary=2 -march=i686 -mtune=pentium4 -Iinclude/asm-i386/mach-default -Wdeclaration-after-statement -Wno-pointer-sign -D"KBUILD_STR(s)=#s" -D"KBUILD_BASENAME=KBUILD_STR(semaphore)" -D"KBUILD_MODNAME=KBUILD_STR(semaphore)" -c -o arch/i386/kernel/semaphore.o arch/i386/kernel/semaphore.c
gcc -m32 -Wp,-MD,arch/i386/kernel/.signal.o.d -nostdinc -isystem /usr/lib/gcc/i486-linux-gnu/4.0.3/include -D__KERNEL__ -Iinclude -include include/linux/autoconf.h -Wall -Wundef -Wstrict-prototypes -Wno-trigraphs -fno-strict-aliasing -fno-common -ffreestanding -Os -fomit-frame-pointer -pipe -msoft-float -mpreferred-stack-boundary=2 -march=i686 -mtune=pentium4 -Iinclude/asm-i386/mach-default -Wdeclaration-after-statement -Wno-pointer-sign -D"KBUILD_STR(s)=#s" -D"KBUILD_BASENAME=KBUILD_STR(signal)" -D"KBUILD_MODNAME=KBUILD_STR(signal)" -c -o arch/i386/kernel/signal.o arch/i386/kernel/signal.c

I never gave it much thought, since the new form was easier to read. I
figured that those folks who still eat kernel code for breakfast knew
about this change well ahead of time. Of course, they were the only
ones who needed to see the verbose output of the gcc
command lines. I could live with seeing the simpler CC
lines for my purposes, until today.

I was compiling kernel code and for the first time since this change in
the Makefiles, I was using a non-default gcc to build
Linux. I wanted to double-check that I’d given the right options to
make throughout the process. I therefore found myself
looking for a way to see the full output again (and for the first
time). It was easy enough to figure out: giving the variable setting
V=1 to make gives you the verbose version.
For you Debian folks like me, we’re using make-kpkg, so
the line we need looks like: MAKEFLAGS="V=1" make-kpkg
kernel_image.

It’s nice sometimes to pretend I’m compiling 0.99pl12 again and not
2.6.20.7. 🙂 No matter which options you give make, it is
still a whole lot easier to bootstrap Linux these days.

Remember the Verbosity (A Brief Note)

Post Syndicated from Bradley M. Kuhn original http://ebb.org/bkuhn/blog/2007/04/17/linux-verbose-build.html

I don’t remember when it happened, but sometime in the past four years,
the Makefiles for the kernel named Linux changed. I can’t remember
exactly, but I do recall sometime “recently” that the
kernel build output stopped looking like what I remember from 1991,
and started looking like this:


CC arch/i386/kernel/semaphore.o
CC arch/i386/kernel/signal.o

This is a heck of a lot easier to read, but there was something cool
about having make display the whole gcc
command lines, like this:


gcc -m32 -Wp,-MD,arch/i386/kernel/.semaphore.o.d -nostdinc -isystem /usr/lib/gcc/i486-linux-gnu/4.0.3/include -D__KERNEL__ -Iinclude -include include/linux/autoconf.h -Wall -Wundef -Wstrict-prototypes -Wno-trigraphs -fno-strict-aliasing -fno-common -ffreestanding -Os -fomit-frame-pointer -pipe -msoft-float -mpreferred-stack-boundary=2 -march=i686 -mtune=pentium4 -Iinclude/asm-i386/mach-default -Wdeclaration-after-statement -Wno-pointer-sign -D"KBUILD_STR(s)=#s" -D"KBUILD_BASENAME=KBUILD_STR(semaphore)" -D"KBUILD_MODNAME=KBUILD_STR(semaphore)" -c -o arch/i386/kernel/semaphore.o arch/i386/kernel/semaphore.c
gcc -m32 -Wp,-MD,arch/i386/kernel/.signal.o.d -nostdinc -isystem /usr/lib/gcc/i486-linux-gnu/4.0.3/include -D__KERNEL__ -Iinclude -include include/linux/autoconf.h -Wall -Wundef -Wstrict-prototypes -Wno-trigraphs -fno-strict-aliasing -fno-common -ffreestanding -Os -fomit-frame-pointer -pipe -msoft-float -mpreferred-stack-boundary=2 -march=i686 -mtune=pentium4 -Iinclude/asm-i386/mach-default -Wdeclaration-after-statement -Wno-pointer-sign -D"KBUILD_STR(s)=#s" -D"KBUILD_BASENAME=KBUILD_STR(signal)" -D"KBUILD_MODNAME=KBUILD_STR(signal)" -c -o arch/i386/kernel/signal.o arch/i386/kernel/signal.c

I never gave it much thought, since the new form was easier to read. I
figured that those folks who still eat kernel code for breakfast knew
about this change well ahead of time. Of course, they were the only
ones who needed to see the verbose output of the gcc
command lines. I could live with seeing the simpler CC
lines for my purposes, until today.

I was compiling kernel code and for the first time since this change in
the Makefiles, I was using a non-default gcc to build
Linux. I wanted to double-check that I’d given the right options to
make throughout the process. I therefore found myself
looking for a way to see the full output again (and for the first
time). It was easy enough to figure out: giving the variable setting
V=1 to make gives you the verbose version.
For you Debian folks like me, we’re using make-kpkg, so
the line we need looks like: MAKEFLAGS="V=1" make-kpkg
kernel_image.

It’s nice sometimes to pretend I’m compiling 0.99pl12 again and not
2.6.20.7. 🙂 No matter which options you give make, it is
still a whole lot easier to bootstrap Linux these days.

The collective thoughts of the interwebz