Pipes are created using PIPE system call. Creation of pipe includes allocation of i-node for the pipe. Two file descriptors are returned. Pipes are owned by the system, not by the user, and are located on the configured pipe device such as RAM disk.

Since, a pipe has a finite capacity, writing to a pipe that is already full will cause the writer to be suspended. Similarly, reading from an empty file will suspend the reader. Hence, a pipe has two pointers which takes care of the current position and the size. Also, writing on a broken pipe – which has no reader – results in error.

Besides these checks, it is also checked if a process previously suspended due to no data or too much data can now be revived, for sleeping writers and readers. Suspending a process involves saving the parameters of the call in the process table and setting flag to inhibit the file system’s reply message. To revive a process suspended on a pipe, a flag is set so that the main loop notices it. This function uses message passing mechanism.

When the memory manager is trying to signal a process, it must find out if that process is hanging on a pipe or special file. Since the memory manager knows nothing about pipes or special files, it sends a message to the file system to ask. Accordingly, the blocked process is revived.

Reference

- Operating Systems: Design and Implementation Tanenbaum, Woodhull

You can download the image here.

Sistem operasi Unix dikembangkan dan diimplementasikan pada tahun 1960-an dan pertama kali dirilis pada 1970. Faktor ketersediaannya dan kompatibilitasnya yang tinggi menyebabkannya dapat digunakan, disalin dan dimodifikasi secara luas oleh institusi-institusi akademis dan pada pebisnis.

Proyek GNU yang mulai pada 1984 memiliki tujuan untuk membuat sebuah sistem operasi yang kompatibel dengan Unix dan lengkap dan secara total terdiri atas perangkat lunak bebas.Tahun 1985, Richard Stallman mendirikan Yayasan Perangkat Lunak Bebas dan mengembangkan Lisensi Publik Umum GNU (GNU General Public License atau GNU GPL). Kebanyakan program yang dibutuhkan oleh sebuah sistem operasi (seperti pustaka, kompiler, penyunting teks, shell Unix dan sistem jendela) diselesaikan pada awal tahun 1990-an, walaupun elemen-elemen tingkat rendah seperti device driver, jurik dan kernel masih belum selesai pada saat itu. Linus Torvalds pernah berkata bahwa jika kernel GNU sudah tersedia pada saat itu (1991), dia tidak akan memutuskan untuk menulis versinya sendiri.

MINIX

MINIX, sebuah sistem bertipe Unix yang ditujukan untuk penggunaan akademis dirilis oleh Andrew S. Tanenbaum pada tahun 1987. Kode sumber MINIX 1.0 tercantum dalam bukunya Operating Systems: Design and Implementation. Walaupun dapat secara mudah didapatkan, modifikasi dan pendistribusian ulang tidak diperbolehkan pada saat itu. Hak cipta dari kode sumbernya termasuk ke dalam hak cipta dari bukunya yang dipublikasikan oleh Prentice Hall. Sebagai tambahan, disain versi 16-bit dari MINIX kemudian tidak secara baik diadaptasikan kepada versi 32-bit dari arsitektur Intel 386 yang murah dan populer yang digunakan secara luas di komputer pribadi.

Tahun 1991, Torvalds mulai bekerja untuk membuat versi non-komersial pengganti MINIX sewaktu ia belajar di Universitas Helsinki. Hasil kerjaannya itu yang kemudian akan menjadi kernel Linux.

Pada tahun 1992, Tanembaum menulis sebuah artikel di Usenet, mengklaim bahwa Linux sudah ketinggalan zaman. Dalam artikelnya, ia mengkritik Linux sebagai sebuah sistem operasi dengan rancangan monolitik dan terlalu terpaku dengan arsitektur x86 sehingga tidak bersifat portable, di mana digambarkannya sebagai sebuah “kesalahan mendasar”. Tanenbaum menyarankan bahwa mereka yang menginginkan sebuah sistem operasi modern harus melihat kepada sebuah rancangan yang berdasarkan kepada model mikrokernel. Tulisan tersebut menekankan tanggung jawab Torvalds yang berujung kepada sebuah debat tentang rancangan kernel monolitik dan mikrokernel.

Sekarang ini Linux telah digunakan di berbagai domain, dari sistem benam sampai superkomputer, dan telah mempunyai posisi yang aman dalam instalasi server web dengan aplikasi LAMP-nya yang populer. Pengembangan kernel Linux masih dilanjutkan oleh Torvalds, sementara Stallman mengepalai Yayasan Perangkat Lunak Bebas yang mendukung pengembangan komponen GNU. Selain itu, banyak individu dan perusahaan yang mengembangkan komponen non-GNU. Komunitas Linux menggabungkan dan mendistribusikan kernel, komponen GNU dan non-GNU dengan perangkat lunak manajemen paket dalam bentuk distribusi Linux.

In my OS course, we use the Minix operating system. We have various assignments that require us to edit kernel source code, etc. We use virtual machines for doing our work, and my preferred VM software is VirtualBox. There seems to be little info about using Minix with VirtualBox on the net, as Minix is not officially supported by VBox. Nevertheless it can be used fine. I am going to write about my own setup in roughly tutorial form.

First, about my software versions. At the time of this writing, I am using:

1. the latest stable Ubuntu, which is Jaunty Jackalope, version 9.04, as the host operating system,
2. the latest stable VirtualBox, which is version 3.0.4, and,
3. the latest stable Minix 3, version 3.1.3a

It is quite simple to install Virtualbox on Ubuntu.

Installing Minix on VBox

http://wiki.minix3.org/en/UsersGuide/RunningMinixOnVirtualBox

My own VM settings are 128 MB RAM and a 1 GB virtual hard disk.

Installing packages

http://wiki.minix3.org/en/UsersGuide/InstallingBinaryPackages

Packages that are useful for me: flex, gcc, emacs, less, make.

Networking

Networking has not been possible to setup. I have tried to get bridged networking to work, so that files can be shared via ssh, but it has not worked yet. I will update if I do succeed. Please post in the comments if you have any tips.

Networking would have been ideal for transferring files both ways between the two OSes, but I am managing with one way transfers for now (Linux to Minix).

Exchanging files between Minix and Ubuntu

I have so far only succeeded in copying files into the guest OS and not vice versa. Since networking has not worked for me, I transfer files via cd images. To transfer single files, create a cd image containing the files in Ubuntu with:

mkisofs -o t.iso <list of single files>

Then, mount the cd image in the VM through VBox’s GUI: Devices->Mount CD ROM. To read the cdrom in Minix, use the isoread, and isodir commands. To copy files from the cd, use a command of the form:

isoread - /dev/c0d2 src.c > src.c

Don’t forget the hyphen after “isoread”.

Copying a whole directory into minix may seem complex using the above method, but the trick is to create a tar file out of the directory we want to copy. We copy the tar archive into minix using the method discussed above and then extract it in the guest.

Getting Minix kernel sources

This initially turned out to be challenging, because though the source code is available in the VM at /usr/src, it can’t be copied to the host for editing using powerful editors in Linux. The source code is available on the Minix cd but it is present in a cd sub-partition that is in the Minix filesystem format. Also, there is no readily available download package on the Minix website.

But there is the SVN repo. The only thing to find is the right revision for the version of Minix we use. Looking the tags folder, helped. To download the sources for my version, I fired off a terminal and typed:

svn checkout https://gforge.cs.vu.nl/svn/minix/tags/r3_1_3a

Enter the username as “anonymous” and enter a blank password.

To get rid of the .svn folders (these are not part of Minix source code) inside the sources folder we downloaded, use the following command from inside the folder created by the subversion checkout:

find . -name ".svn$" | xargs rm -rf

Now our sources are ready for editing.

Recompiling the Minix kernel

After we edit sources, we copy the files into Minix’s /usr/src. Then, from /usr/src/ we type:

make world

If everything works, this builds a new kernel and sets it up for booting. Type “shutdown” to shutdown the VM, and from the boot prompt, type “boot d0p0″ to start minix. In the resulting boot menu enter “3″, and we boot into the kernel we just modified! More information about recompiling is here.

Yesterday I attended to an event at a local University where my friends from the Ubuntu Loco Team did some talks on Free Software. One of the talks, the one I considered the most intersting of them all was about Free Software in Education. My friend Eivar Montenegro talked about the importance of Free Software when it comes to Schools and Universities and how it would benefit the current educational system. One of the benefits he mentioned was the fact that it would be cheaper, something I strongly disagree with, not because it’s false, but because it would mean that teaching using freeware is also as valid as using Free Software, and that’s clearly against the position of our Community.

Yet this post is not about a reflexion on tha matter, but about a reflexion on a question someone asked after the talk: Some random guy asked what was the validity of teaching Free Software in modern days when all of the IT business is ruled by one company (I assume he was talking about Microsoft) and it’s Propietary Software.  My friend answered that business was not exactly ruled by one Propietary Software company and cited some succesful Free Software projects like Apache and MySQL as examples of mainstream projects actively used in business.

Although it might be true, I still consider that answer as a weak answer to a very misleaded question, because we are talking about Education, not about the hottest trends in IT. But it’s a very common mistake from the Universities in Panama to confuse phrases like “Prepared for the Future” and “Ready for Business Challenges” with “Cisco Certified” or “Microsoft Visual Studio .NET Ready”. But the truth is, my friends, that these are not equivalent concepts. Teaching someone about a particular tool or set of tools, no matter how big that set of tools is, is nothing close to educating. There’s no point on teaching a student how to create a database schema under Oracle DB when that student is not capable of analyzing a real life problem and coming up with a well-designed database-driven solution for it, or teaching a student all of the new features of the latest Visual C++ implementation when that student can’t apply that programming knowledge to optimize an existing algorithm.

Having students prepared for the latest tools available in the market is just an absurd race against trends which change rapidly every year. Considering that an average major in Panama is obtained after 3 or 5 years of studies, it’s just plainly stupid to think you can develop carreer plans based on tools and not on concepts. Furthermore, whatever tool a student learns during his career is surely going to do one of two things in the near future: evolve or dissappear and when that happens, everything he knew about that tool will render unuseful on the Market some University once told him he was prepared for. Since it’s a very well know fact that people’s ability to learn is degraded with the past of the years, it will be a lot more difficult for that “professional” to learn something new and he will probably be replaced by newly graduated students that will start the process all over again. And even if that sounds comfortable enough to some old professors that know they can always accomodate to such a system as they can’t actually be fired from the University because of all the years they have been in it (at least that happens in my University), well, the concept of metaprogramming is going to catch you all: We will eventually be able to make programs that are capable of doing general purpose programming, and once we get to that point (and we are not far from it, judging by the complexity of parsers and compilers) there won’t be a need to hire people to do that.

So how can Free Software help the Educational System prepare real-valued students? This question has been answered previously: consider Andrew Tanenbaum’s classic book “Operating Systems Design and Implementation”. What was it that made that book such a bestseller? Besides the great expertise from such a master of Operating Systems, the book came with the world famous MINIX. Why was that? Because Dr. Tanenbaum knew that there’s no way to learn as an expectator. The students needed to test and think out of the box and you can see that approach throughout the problems at the end of each chapter: most of them ask students to modify the MINIX so that it could do something that the distributed version wasn’t capable of doing yet. Couldn’t the author simply write a big book on UNIX commands? Yes he could, but he knew that was NOT teaching. He probably knew that there was great chance that in the near future UNIX wouldn’t be mainstream in the market, but even if that happened, he knew that the concpets that built UNIX will still be useful, maybe not as breakthrough ideas anymore, but at least as bases for new features to be added on modern operating systems.

Free Software gives students the power to think beyond the capabilities of the existing tools, and at the same time teaches methods and values that cannot be taught in the regular IT curriculum, like sharing the modified concepts and world-wide team-based projects. Students would no longer worry about learning what command creates a thread on a specific languge, and instead use that time to think on better ways to implement any single threaded existing library in modern multicore CPUs using any given open language like Java. This kind of Educational System frees the professor from the burden of teaching language-specific material (we have the Web to do so) and empowers them with the ability to teach models  and concepts that will endure as languages and platforms change (after all, Object Oriented Programming is close to 50 years of existance, but most of the students in my University are still not sure of where to put the class keyword on a C++ program).

Are you not convinced on my argument? Well, try searching for these two phrases: ‘SQL Server Tutorial’ and ‘Sharing Tutorial’. The first one is searching for a tutorial on how to use MS SQL Server, did you find any? The second one was searching for a tutorial on how to share valuable information and knowledge in a community and the importance of it, did you find any results regarding that concept? Well, it looks like its a lot more difficult to teach students a single value like sharing, than to teach them many of the latest tools.

But then it looks like Free Software solved the problem for the IT Educational world, didn’t it? Well it didn’t. It actually did more than that. It solved many other aspects of Education on many other areas. That’s because Free Software stands not for Software Freedom, but for Human Freedom. The legal aspects of Free Software are still challenging topics on modern discussions on Copyright laws. Social Sciences are also backing up the Free Software movement as the only alternative to modern monopoly trends that have turned our society into a marketplace of possible buyers. So Free Software is not just about a hacker’s right to see the code, it’s about a society’s right to grab the future with its own hands.

Back in the 80’s it was not easy to be a computer geek! It was a requirement to be involved somehow with a university or a big mammoth organization that had supercomputers. And even meeting those criteria, it still required bribing the janitor for a couple of extra hours of “Hacking”  late at night (In the white sense)

As personal computers started spreading, there was a need to have a powerful operating system such as Unix: entirely unavailable for personal use due to licenses. At this point Professor Tanenbaum in Netherlands had created Minix to be an educational version Unix-like for his class in Operating Systems, allowing thousand of students and enthusiast to play with it and modify it at their own taste; this served as an inspiration for Linus Torvalds to start his own operating system; even though, it wasn’t meant to be more than amateur project. As explicitly said by Torvalds in his first post in the comp.os.minix mailing list :

I’m doing a (free) operating system (just a hobby, won’t be big and professional like gnu) for 386(486) AT clones. This has been brewing since April, and is starting to get ready. I’d like any feedback on things people like/dislike in minix, as my OS resembles it somewhat..

A community behind this new Minix clone formed rapidly, leading to the first stable version within 6 months.

As with evolutionary changes not always the best fitted changes are the ones that succeed. At the time when Linux came out, it could have been perfectly plausible for Minix to have become the de facto distribution or even more likely the GNU Hurd operating system that was under heavy development in the MIT Labs.

Some of the events that allowed Linux to shine:

• Minix was never entirely free, the license to the program was acquired through the purchase of his book
• At MIT the GNU Operating System group had divided opinions into the Kernel architecture to use, (Monolithic or Micro Kernel)
• The kernel by itself is useless, without all the applications that support it. GNU group developed many of the applications external to the kernel, allowing Linux to make use of many of these apps. Without it, it could have probably never gone any further from just an amateur idea. This led to the controversial naming GNU/Linux, both sides were equally critical.
• The development of a free Unix distribution (FreeBSD), started a few years too late.

More than a historical recount, this post serves as a tribute to many of the things that made GNU/Linux what it is. Even a great idea, such as GNU Hurd is nothing without the support of a community; proof is that after almost 20 years still struggles to have an stable version.

So, here’s a little sidenote to what I’ve been doing.  Those who know me, know I LOVE coding, and that I sometimes stay up a little bit (read: way too much) late at night coding.  Here’s some of the hilarity that ensued.

Implementing the new level0()

This was funny since it was a simple mistake, but th e symptoms were so crazy.  I was getting hundreds of errors, and while the overwhelming majority of them were from cascading failure, the inital errors made no sense.  The compiler was complaining about a struct in a random header file, and interpreting it as a function.  It then thought the members of that struct were arguements that had not been declared in the function, so on and so forth.  Turns out in a completely different header file, I missed a semicolon after a variable declaration (the new pointer for the arguements to hand to level0), which happened to be the last actual code in that file.  After the preprocessor ran and concatenated all of the #includes together, it ended up that the unfinished statement with the arguement pointer was getting tacked onto the struct.

do_wrmsr()

If I didn’t learn enough from the first error, I did a (similar) thing again… This time it was much quicker to debug, but still the error messages were puzzling.  I was reworking the kernel functions to be run with the new level0() function, and got the error that there were extra arguement types in the function declaration.  After fixing up the function declaration a few times, I went back up to the last thing before it.  I’d defined a struct to hold the arguements for the rdmsr, and sure enough, forgot a semicolon at the end.

Soapbox Time

At this point I’d like to get up and say a bit about language design and programming today.  I have no problem working with C and assembly (and even hex).  In fact, I prefer this to pretty much any other lanugage setup out there.  I’m a low-level kinda guy and I’m comfortable in C/asm, even if it’s sometimes harder to debug than other languages.

That being said, I’ve been reading up on some other language design principles and ideas.  Notably: verification and contracting.  These are two separate ideas to a common goal: reduce bugs and make code more reliable.

First: Verification.  This is the process of proving that your code behaves as expected.  This is very commonly seen in hardware description languages like Verilog, used when designing discrete hardware structures.  Even Prolog can be considered a form of verification.  For register-level computer chips and logic functions, the process of verification is simple.  But take even (relatively) simple languages like C or Fortran, and verification quickly becomes intractable.  For C the problem is clear: anonymous pointers.  These ruin the typesafety and general security of your language, but make for nice workarounds for an otherwise typed languge.

Second: Contracts.  This is something that goes into your code, and in short they are restrictions.  Restrictions on the input, output, or even in-between.  Contracts are typically what the software verification tries to prove (or disprove).

As much as I dont like Microsoft, I have a great deal of respect for what they’ve done in MSR to study this.  Of note are three projects:

• Spec#: basically C# verified, with other improvements thrown in (like the Bartok compiler)
• Code Contracts: also in C#, this package adds contracting functionality to Visual Studio
• Singularity: A microkernel OS that utilizes all of these principles and more (such as signing)

I will continue to follow these, but I think its time for the open source community to step forward and catch up.  I’ll admit as an undergrad I’m not quite ready to make a language just yet, but I’m working on it with a friend of mine (who, ironically enough, loves staying on the high-level side of things. we make a good team).  We’ve been studying everything we can get our hands on, from Ameoba, to Scala, to Alan Kay’s talks on language design to E and Eiffel, to functional languages, to HDLs, to automated theorem proving.  We might be ready by the time we get our degrees….hah….

And you know what they say about plans.

One of the problems I’ve run into while trying to get a PMC driver up-and-running is that several fundamental operations used to set up the counters have to be run at ring-0.  In Minix, only the kernel can do this (my driver runs as a user-level process), so I have to request the kernel carry out these operations for me.  Even the kernel only runs the code it has to at ring-0, using a function called level0().  This function takes a single function pointer, and runs it at ring-0.

My problem with this is that the function you hand in can’t have any arguements with it.  There was no way I was going to make new functions for every event or value I might set a counter to, so I modified it in such a way as to allow arguements to be passed in as well.  Many thanks go out to Tomas Hruby for coming up with this and working with me through the details of it.

The old version would go as follows:

level0(foo);

Where foo() is some function that you want to run at ring-0.  Notice it doesn’t have any ()’s after it; thats because its a function pointer, and function pointers cant take arguements.  This is how the new version goes:

level0(foo, args);

Where args is a pointer (void*) to a structure containing your arguements.  foo() will need to know how to dereference this pointer, but for example you could point to a structure that has multiple arguements, allowing you to effectively pass in multiple arguements.

Yes, I understand there is a security concern with this, so I wouldnt expect to see it in the trunk soon (if at all).  My arguement is that having an anonymous arguements pointer is no less secure than the anonymous function pointer, but it may be dereferencing arguements that aren’t well secured.  For now I’m not *too* worried about the security implications of this, as my branch is not as destined for merging to the general populace as the other GSoC projects (as its kind of processor-specific), but it’s something I’ll look into in the future.

Right now my new level0() function is sitting beside the old one, but it will eventually replace it.  It is level0_ajray and level0_call_ajr respectively in my trunk (check out kernel/arch/i386/klib386.s and mpx386.s).

*Linux: /lee´nuhks/, /li´nuks/

Unix yang seluruh source codenya dibuat dengan bahasa C sangat  memudahkan
pengembanganya sehingga dalam waktu singkat Unix  dapat  berkembang secara
pesat, dan terbentuklah dua aliran : yaitu Unix   yang  dikembangkan  oleh
Universitas Berkeley dan yang dikembangkan AT&T.

Semakin lama semakin banyak perusahaan yang ikut melibatkan diri, sehingga
terjadilah persaingan antar perusahaan   untuk memegang  kontrol  terhadap
sistem operasi. Persaingan ini menyebabkan perlunya sebuah standar yang baku
sehingga lahirlah proyek bernama ‘POSIX’ yang di  motori  oleh   IEEE (The
Institute of Electrical and Electronics Engineers)  yang  akan  menetapkan
spesifikasi standar Unix. ternyata, dengan adanya standar  tersebut  tetap
belum bisa meredakan persaingan yang timbul  yang  mengakibatkan munculnya
berbagai varian dari Unix.

Source code  Minix yang tercipta sebagai salah satu varian Unix dan dibuat
oleh Andy S Tanembaum untuk tujuan pendidikan inilah yang dijadikan  Linus
Torvalds sebagai referensi untuk membuat suatu Opeating system  yang dapat
bekerja seperti Unix dalam komputer  386.  Dalam  pembuatan  linux , Linus
memakai tool-tool dari Free Software Foundation yang berlicensi GNU.  Agar
sistem operasi yang baru dibuatnya utuh , linus juga menambahkan program-
program yang berlicensi GNU. Linux yang dibuat linus sebagai hobi akhirnya
membuahkan versi pertama linux, yaitu linux versi 0.0.1, setelah mengalami
perbaikan pada versi 0.02 dan merupakan linux resmi pertama yang diumumkan
secara luas kepada publik. pada tanggal 5 Oktober 1991 linus  menggumumkan
source codenya.

Linux yang pertama dirilis sudahdapat menjalankan shell bash,GNU C compiler
, GNU make, GNU Sed, Compress dll. Proyek linux ini menyita begitu banyak
perhatian seluruh programer di dunia yang akhirnya  berpartisipasi  untuk
ikut mengembangkan linux.

‘Linux’ bisa jadi merupakan proyek  para  hacker  yang sangat berharga di
dalam sejarah – serta didistribusikan secara bebas beserta kode sumbernya
keseluruh dunia.

[Sejarah Linux - END]

“UNIX” IS BORN

Cikal   bakal   kelahiran linux dimulai pada  akhir   tahun 1960 pada sebuah
perusahaan   AT&T(American Telephone and Telegraph).   Saat itu, AT & T yang
bekerjasama dengan    MIT (Massachusetts Institute of Technology);   bekerja
dengan menggunakan   operating system   bernama  “multics”. Multics memiliki
banyak    sekali masalah; masalah terbesarnya   adalah   mahalnya biaya yang
dikeluarkan untuk menjalankannya pada General Electric Mainframe  ( GE 645).
Perkembangan selanjutnya pun menjadi tidak memuaskan.

Bagaimanapun juga penggunaan Multics  tetap  dipertahankan karena menawarkan
kemampuan multiuser (penggunaan bersama).   Para   Programer  harus  bekerja
bersama-sama dan saling bertukar informasi dengan mudah, dan mereka   sangat
ingin untuk dapat lepas dari masalah    biaya  yang  besar.  Seiring  dengan
perkembangan dan keuangan  yang  membaik, grup tersebut  berusaha    mencari
pengganti yang sesuai untuk multics.

Ken thompson, salah seorang anggota grup AT&T,   mulai merancang sebuah game
bernama”Space travel”, sayangnya game ini juga menghabiskan biaya yang mahal
untuk dapat dimainkan. Saat Thompson menemukan sebuah komputer digital PDP-7,
bersama teman   kuliahnya Dennis Ritchie, mereka menulis ulang game tersebut
dalam assembler dan     memindahkannya dengan   menggunakan   paper    tape.
Dalam perkembangan   memindahkan  game  tersebut  mereka  telah   meletakkan
“command     interpreter” dan   sejumlah  perintah dasar  untuk mengkopi dan
memindahkan file-fie.

Awal  tahun 1970, Brian Kerningham, seorang  pengembang  lainnya  dari  AT&T
mengusulkan nama “Unix” sebagai pelesetan dari Minix  (     peralatan  untuk
mengajarkan pemrograman). Dimulailah sebuah cikal     bakal sebuah operating
system bernama “Unix”.   Team pengembang Unix meminta komputer PDP-11 kepada
manajemen AT&T, mesin yang lebih tangguh dari PDP-7,tetapi lebih murah dari
semua biaya yang harus mereka keluarkan sebelumnya.

>TO BE CONTINUED<

[Sejarah Linux - Part 1]

I’m working on Minix right now

~ sam

C’est avec délectation que j’ai lu un article sur le MondeInformatique.fr selon lequel le professeur Andrew Tanenbaum (appelé affectueusement Andy dans l’article) aurait reçu une subvention de l’Union Européenne pour le développement de MINIX, un système d’exploitation qu’il a développé et qu’il veut stable et sans plantage.

Le professeur Andrew Tanenbaum, (selon Wikipedia), est né à New York, en 1944. Il réside au Pays-Bas. C’est un chercheur et enseignant en Informatique. Actuellement, il dirige le département des Systèmes informatiques à l’université libre d’Amsterdam où ses enseignements sont très axé sur les systèmes d’exploitations.

Il est l’auteur de plusieurs ouvrages dont “Modern Operating systems (Systèmes d’exploitations)”.

Hormis ses publications d’excellente qualité scientifique, il est aussi l’auteur de MINIX, un clône libre d’UNIX. Au début, Andrew avait voulu MINIX un simple outil didactique pour lequel il avait imposé des limitations techniques qui ont frustré pas mal d’utilisateurs, dont Linus Torvalds, qui initia alors le développement du noyau Linux, aujourd’hui largement utilisé sur les systèmes d’exploitations libres.

Andrew Tanenbaum est très connu pour sa prise de position pour l’architecture micro-noyau pour un système d’exploitation moderne. L’avantage, selon le professeur, c’est que le système devient ainsi très stable, et peut ne jamais se planter. Une partie du noyau qui ne répond plus pourra être déchargée de la mémoire sans arrêter, dans la plupart des cas, l’ensemble du système. MINIX est un exemple de système d’exploitation à architecture de micro-noyau. Hurd, en cours de développement par la Free Software Fondation en est un autre.

A l’opposé, il y a les systèmes d’exploitations monolithiques (à base d’un noyau monolithique comme Linux) qu’Andrew Tanenbaum dans son livre “les Systèmes d’exploitations” dit être sans structure; un ensemble des fonctions pouvant être appelées depuis n’importe quelle autre.

Néanmoins, après avoir craché sur Linux, qui est monolithique, il a fini par reconnaître ses performances et semble en être fier, puisqu’il dit de son propre système MINIX qu’il est le précurseur de Linux.

MINIX sera désormais orienté vers le grand public. Avec une subvention d’ordre de 2,4 M€, Andrew Tanenbaum compte faire de l’ordinateur un outil aussi stable qu’une télévision ou un téléphone. Afin que “l’utilisateur moyen ne connaisse aucun plantage dans sa vie”. MINIX est sous licence libre BSD.

Richard Stallman, est un autre partisan des systèmes d’exploitation à base de micro-noyau. Et il participe au sein de la Free Software Fundation au développement de Hurd qui utlise l’artitecture micro-noyau. On peut expérimenter Hurd avec la distribution Debian/Hurd, en cours de développement.

• The Second Law and Cosmology (arXiv:0904.3931v1 [physics.pop-ph]); Eu recomendo fortemente que, aqueles que quiserem ler esse artigo, o façam em paralelo aos comentários do Penrose em “The Road to Reality“, Capítulo 27.
• p-Adic Mathematical Physics. (arXiv:0904.4205v1 [math-ph])
• An approach to a theory of quantum gravity (discussão sobre esse artigo nos ‘comentários’ abaixo)
• Thermal Vacuum Radiation in Spontaneously Broken Second-Quantized Theories on Curved Phase Spaces of Constant Curvature. (arXiv:0904.3814v1 [hep-th])
• Quantum fields on curved spacetimes and a new look at the Unruh effect. (arXiv:0904.3751v1 [hep-th]) mais-ou-menos comentado em Some musings about Unruh effect
• Seiberg-Witten equations from Fedosov deformation quantization of endomorphism bundle. (arXiv:0904.4409v1 [hep-th])
• Local systems: the path groupoid approach
• Three ways of looking at a local system: Introduction and connection to cohomology theories: ver também Matthew Emerton is smart and helpful.
• The Earth – For Physicists
• The most influential journals: Impact Factor and Eigenfactor

• The White House – Press Office – Remarks by the President at the National Academy of Sciences Annual Meeting: a diferença que faz um “Plano de Nação” (de 50 anos!) para um país.
• Europe Funds Secure Operating System Research: pra quem não conhece, eu recomendo se familiarizar com a história do projeto GNU, Free Software, do kernel do Linus — que foi baseado no minix —, e assim por diante… só pra por tudo isso em perspectiva
• Drinking tea with the LHC