Archive
What is Ventoy, and why you should always have one!
TL;DR;
Before I get to ranting, here is the quick answer:
Ventoy is a Free Software multi-platform tool that lets you boot ISO files from a USB drive.
Key features that make it different from other tools like Etcher or Unetbootin are:
- You don’t need to “flash” the ISO to the drive – just copy like a regular file!
- You can still use your drive normally to carry other files around!
- You can put as many ISO files as will fit on the same USB stick and choose which to boot!
- It supports GNU/Linux, BSD, and even Windows ISO files!
The rant:
One thing I hate the most about GNOME project is the fact that starting with version 3, they been systematically destroying their utility apps.
Calculator button layout has become a ridiculous mess, setting Alt + Shift to switch keyboard layout requires a 3rd party tweak tool, and my biggest gripe: the “startup disk creator” has been completely boarked!
Back in 2007 I was able to use GNOME 2’s built in tool to create a persistent live USB stick for a friend in need with just a couple of clicks, while simultaneously preserving the files he already had on that USB drive!
Fast forward to 2021 and all I get is a thin GUI wrapper for dd command, which not only does not allow creating a persistent installation, but also converts any USB drive in to a 2GB DVD messing up partitioning and even sector size!
Sure, it boots, but it is unusable for anything else, even flashing a different image, unless I clean it up with GParted first.
It is almost like the GNOME project intentionally tries to sabotage it self by becoming more and more useless!
My current predicament:
Even as I type this post my home desktop computer still runs Ubuntu 16.04.
One of the major reasons I am running a 5 year old version of Ubuntu despite their regular release schedule is the rant above – I did not want to update many of the GNOME components Ubuntu relies on to their newer, more decrepit versions. (And no, I don’t want to switch to KDE, thank you.)
But now the time has come where I can’t put it off any longer:
Arduino Studio 2.0 requires newer glibc, many of the Python scripts I write use 3.9 features, and some free software projects I really want to build require higher versions of cmake than that wich comes with my current distribution.
Plus, even though this is an LTS version, it will be nearing its end of life soon…
So I tried to run dist-upgrade only to find out that all the messing around with repositories and packages I did over the years messed up my setup so much, it can no longer upgrade.
After trying to solve the issue for a few days with no success, I decided the simplest way forward was to just install a newer version over the old one.
Though my home and my boot partitions are separate, I still took the time to image both with Clonezilla to a backup removable drive.
And a good thing too, as I got careless and managed to destroy both partitions during the upgrade attempt, even though they are on separate physical drives!
Fortunately, the full disk image backup worked like a charm, and I did not loose anything other than a few hours of my life.
But the problem was this:
First, I needed a bootable USB stick with Clonezilla, then one with latest version of Ubuntu, then Clonezilla again, then one with older version of Ubuntu to try again (because I suspected the installation failed because my system does not support UEFI).
I don’t have a bunch of USB drives lying around, and reflashing the same drive with my laptop was a pain in the ass.
Today I went to get a few things from my local computer store and was going to get another 32GB Sandisk stick to avoid this hassle in the future.
They didn’t have one on display, but they did have a Kingston 128GB stick, so before sending the nice clerk to fish one out of the storage room I asked how much the 128GB USB stick cost.
Turns out it was less then a ribs serving at my favorite restaurant.
So I got the bigger stick instead, and remembering hearing about this “Ventoy” thing somewhere decided to give it a try.
The experience:
Though they do not have repositories, not even snap, they do provide a statically linked binary which can be run after unpacking from the tar file without installation.
The interface is super simple, though I have not tried their persistence feature yet, which requires running a separate script.
The tool warned me (twice!) that all the data will be deleted from my USB drive, but when it was done I still had a clean 127GB drive with no garbage files on it, and no messed up partitions.
Then I dropped a few ISO files on it.
I have a tendency to keep all the ISOs I try out, and I tried out a bunch of OS’s from Puppy Linux to PC BSD back in the day, so it was a matter of a few minutes to copy them over USB 3 port.
And…
It worked just as advertised!
I got a pretty graphical menu letting me select any of the ISOs I put on the drive, and then the selected one just booted.
PC BSD couldn’t get in to a GUI and dropped me to console, but I suspect this has to do with my new nVidia card. This ISO is very old, I don’t remember when I got it, and it seems PC BSD has been deprecated for years (I don’t really follow the BSD world).
I will try out Midnight BSD 2.1.0 later on, as I am curious both about how well BSD is supported by Ventoy and what modern desktop BSD looks like.
Ubuntu 21.04 booted without issue.
Conclusion:
Instead of a handful of thumb drive strung around my desk I now have one drive that serves all my needs:
I can use to to back up my files and whole disks, I can use it to install old and new Ubuntu distros, I can use it to try out new OSs, and I will probably add the Rescue CD image to it later just in case.
I even have a DBAN ISO on there, though I am not planning on nuking any drives any time soon.
And after all that I still have 117.9 GB free on the drive, and only 5 distinct ISO files in the root directory, so I can freely use this drive to carry around other stuff without it mixing in with the OS install files and folders.
And I can add more ISOs any time, in minutes, without any special tool (Ventoy is not needed after installing the bootloader).
There is no configuration, nothing!
Which is why I highly recommend this tool!
It lets you keep a single USB stick as a multitool for all your external booting needs, from installing new OS to fixing and backing up.
And its super easy!
After trying out several different “flashers” in the past, I found this particular tool so useful and convenient that I donated 20$ to the developer to show my support.
Heck, it may even be good for the environment by reducing e-waste through reducing the number of USB sticks people like me will need.
Those things do break pretty easily, especially ones with full plastic casing, even from reputable manufacturers (which is why I now only buy ones with metal casings, though that still does not guarantee survivability of the chips inside).
Disclaimer:
I don’t really know anything about the developer behind this project, or the project it self beyond what I experienced using it.
I have not audited the code.
So don’t rely solely on my excitement in this post and check it out for your self!
The code is available here and here, it is under GPL v3+ which is an excellent choice that shows the developer really cares about freedom of users down the line.
Update:
I should have read the fine print on MidnightBSD. It is not a LiveCD, it is just an installer.
And it does not like my system at all…
Trying to run it directly from a USB drive (using dd) didn’t even get past initial bootloader, while via Ventoy it scanned all my hardware, switched to graphical mode momentarily, then prompted me for “boot device”, which I didn’t know so I could not continue.
Guess they really need to work on their user friendliness, or be less picky about who they befriend 😛
Maybe I will give them a try on VirtualBox after I am done with my system upgrade…
Putting it out there…
When I first discovered Linux and the world of Free Software, I was already programming in the Microsoft ecosystem for several years, both as a hobby, and for a living.
I thought switching to writing Linux programs was just a matter of learning a new API.
I was wrong! Very wrong!
I couldn’t find my way through the myriad of tools, build systems, IDEs and editors, frameworks and libraries.
I needed to change my thinking, and get things in order. Luckily, I found an excellent book that helped me do just that: “Beginning Linux Programming” from Wrox.
Chapter by chapter this book guided me from using the terminal, all the way up to building desktop GUI programs like I was used to on Windows.
But you can’t learn programming just by reading a book. You have to use what you learn immediately and build something, or you will not retain any knowledge!
And that is exactly what I did: as soon as I got far enough to begin compiling C programs, I started building “Terminal Bomber”.
In hindsight, the name sounds like a malware. But it is not. It’s just a game. It is a clone of “Mine sweeper” for the terminal, using ncurses library.
I got as far as making it playable, adding high scores and help screens. I even managed to use Autotools for the build system.
And then I lost interest and let it rot. With the TODO file still full of items.
I never even got to packaging it for distribution, even though I planned from the start to release it under GPL v3.
But now, in preparation for a series of posts about quickly and easily setting up HTTP server for IPC, I finally opened a Github account.
And to fill it with something, I decided to put up a repository for this forgotten project.
So here we go: https://github.com/lvmtime/term_bomber
Terminal Bomber finally sees the light of day!
“Release early release often” is a known FOSS mantra. This release is kind of late for me personally, but early in the apps life cycle.
Will anything become of this code? I don’t know. It would be great if someone at least runs it.
Sadly, this is currently the only project I published that is not built for a dead OS.
Just putting it out there… 😛
One of these things is not like the others!
Please look at the following picture:
These are “smart” phones I own.
All of them have different hardware specs, but one is truly different from the others.
Can you tell which one?
It’s the one on the right – i-mate Jamin.
It is also the first “smart” phone that I ever owned.
What makes it different from the others?
The fact that it is the only one in the bunch that does not run on Free Software.
I was inspired to take this picture and put it on my blog by another post (in Hebrew), that talks about black, round corner rectangles and the recent madness surrounding them.
But I am not going to write about that.
There are already plenty of voices shouting about it all over the Internet, and I have nothing constructive to add.
Instead, I will introduce you to my lovely phone collection, which contributed a lot to my hobby and professional programming.
And we will start with the historical sample on the right: i-mate Jamin. (specs)
Back in early 2006, when this device came out, “smartphone” was still a registered trademark of Microsoft, the name they chose for the version of their Windows CE based mobile OS for devices with no touchscreen. (The touchscreen version was then called Windows Mobile Phone Edition)
Such devices were for geeks and hard core businessmen who had to be glued to their office 24/7.
But despite having a proprietery OS, this was a very open device: you could run any program on it (we didn’t call them “apps” then), and you could develop for them without the need to register or pay.
It didn’t matter what country you were from, or how old you were. The complete set of tools was available as a free download from Microsoft’s site.
And the OS allowed you to do a lot of things to it: like its desktop cousin, it completely lacked security, you could even overwrite, or more precisely “overshadow” OS files that were in ROM with a copy with the same name stored in user accessible NAND flash (or RAM on older devices).
The system API was almost identical to the Win32 API, which was (and still is) very common on the desktop, so if you knew how to write a program for your Windows powered PC, you knew how to write a program for your phone.
Unlike the systems we are used to today, Windows Mobile had no built in store.
You were on your own when it came to distributing your software, though there were several sites that acted much like the application stores do today: they sold your program for a commission.
But that too meant freedom: no commercial company was dictating morals to the developers or telling them that their program had no right to exist because it “confused users” or simply competed with that company’s own product.
So even though the OS brought with it most of the diseases common to desktop versions of Windows, it gave developers a free range, and thus had a thriving software ecosystem, until MS killed it off in a futile attempt to compete with Apple’s iOS and Google’s Android by taking the worst aspects of both.
The second phone from the right is the Neo 1973.
It was so named because 1973 was the year the first cellular call was made.
I got this device in 2008. By that time, I learned a lot about software freedom, so when I heard about a completely free (as in freedom of speech) phone, I just had to have it.
It wasn’t easy: it could only be bough directly from the company, which meant international shipping and a lot of bureaucracy with the ministry of communication that required special approval over every imported cellphone.
I was particularly concerned because this was not a commercially available model, despite having FCC certification, so it was possible that I could not get it through customs as a private citizen.
In the end, the problem was solved, though not before customs fees and added UPS charges almost doubled the cost of the device.
It felt great to have it. I never had such complete freedom with a phone before.
But then I realized – I had no idea what to do with this freedom! Developing for the OpenMoko Linux distribution (later, the project switched to SHR) was very different from developing for Windows.
I had a lot to learn, and in the end, I wound up making only one usable program for my two Neo phones: the screen rotate.
One of the things that amazed me about the OpenMoko project was, that even though the software and hardware were experimental and in early stage of development, in many ways they were much better then the commercial Windows Mobile that was being sold for years to many phone makers.
For example, OpenMoko had perfect BiDi support needed for Hebrew and Arabic languages, as well as fonts for those languages shipped with the OS.
This is something MS never did for Windows Mobile, despite having a large R&D center in Israel for almost two decades, and having a large market in other countries that write right-to-left languages.
Also, the Internet browser, though slow, was much more advanced then the one on WM, and even came close to passing the Asid2 test.
The only trouble was, I could never get the microphone working. It didn’t really matter, since I wanted the phone for development and testing, and didn’t intend to carry it around with me for daily use.
Which brings us to the next phone in the collection: the Neo Freerunner.
This was the second device from the OpenMoko project, the more powerful successor to the Neo 1973.
At first, I swore I would not by it. There just wasn’t enough difference between it and the original. Sure, it had WiFi and a faster processor, but is that really a reason to by another phone?
But by that time, my trusty old Jamin was getting really old, it developed some hardware problems and even with a new battery would not charge well.
I had a lot of choice in smartphones, working for a company that developed software for them, yet I could not bare the thought of buying yet another non-free phone.
So in the end I broke, and bought the Freerunner, mostly for that nice feeling of carrying a tiny computer in my pocket, made completely with Free Software and Open Hardware.
Thanks to Doron Ofek who put a lot of effort in to advancing the OpenMoko project (and other Free Software projects) in Israel, getting the second device was much easier.
And so it became my primary and only cellphone for the next three years.
I don’t think there are too many people in the world who can honestly say they used OpenMoko phone as their primary cellphone, with no backup, but I was one of them.
Flashing a brand new OS twice a month or more (if I had time) was just part of the fun.
Sadly, all good things come to an end. The life expectancy of a smartphone is 18 month at best. I was seeing powerful Android based devices all around me, with large screens, fast processors, and, most importantly – 3G data (I spend a lot of time out of WiFi range).
And I wanted a stable device. As much as I hated to admit it I needed a break from living with a prototype phone and a rapidly changing OS.
But I wasn’t ready to loose my freedom. And I didn’t want to completely surrender my privacy.
Most Android devices need to be hacked just to get root on your own system. And even though the OS is Free Software, most of the “apps”, including built in ones, are proprietery.
And of course, Google is trying to milk every last bit of your personal information it can, and trying to keep them from doing it on Android is very uncomfortable, though definitely possible.
This just won’t do.
Finally, I found a perfect compromise:
My current phone – Nokia N900 (spec).
It was far from being a new device, when I finally ordered one thorough eBay.
It had a major downside compared to any Android device – it had a resistive instead of capacitive touchscreen.
Yet it was the perfect merger, borrowing from all worlds:
It runs mostly on free software, with a real GNU/Linux distribution under the hood, unlike Android which uses a modified Linux kernel, but has little in common with what most people call “Linux”.
It has a proper package manager, offering a decent selection of free software, and updates for all system components including special kernels, but also connected to Nokia’s OVI store.
It even came with a terminal emulator already installed.
Unlike the OpemMoko project, this was a finished and polished device. With a stable, simple, useful and convenient interface, widgets, and all applications working satisfactory out of the box.
It even has the flash plugin, which, though a horrible piece of proprietery software on which grave I will gladly dance, is still needed sometimes to access some sites.
So here I am now, with an outdated, but perfectly usable phone, that can do just about anything from connecting USB peripherals to mounting NFS shares.
It is perfect for me, despite it’s slightly bulky size and relatively small 3.5 inch screen.
But I know that no phone lasts for ever. Some day, the N900 will have to be retired, yet I see no successor on the horizon.
With Microsoft and Apple competing in “who can take away most user rights and get away with it”, and Android devices still containing plenty of locks, restrictions and privacy issues, I don’t know what I will buy when the time comes.
Who knows, maybe with luck and a lot of effort by some very smart people, the GTA04 will blossom in to something usable on a daily basis.
Or maybe Intel will get off their collective behinds and put out a phone with whatever Meego/Maemo/Moblin has morphed in to.
Even Mozilla is pushing out a Mobile OS of sorts, so who knows…
What do you think?
Solutions vs Products
I originally intended this blog to be about development, with programming tips, tricks, and maybe even following some open source project of mine, but for now, I just couldn’t find any suitable material of this kind to publish.
Most of the new stuff I learned recently was already well documented else were, and I did not want my blog to be a copy of a copy bringing no added value.
But I don’t want it to be strictly opinionated rants ether, so I decided to start a new series, which is something in between: technical examples (not necessarily code), that go to prove my strong opinion that Free and Open Source Software is better than closed source non free software.
I call this series: “Solution vs Products”.
In Free Software, developers always seek to provide a solution for a certain problem. Software solution that will fulfill a certain need. Very often, it is their own need, but that does not mean that others do not benefit greatly from the solution.
Companies, that build their business on Free and Open Source software like RedHat and Canonical, make money from providing solutions to their customers, not simply selling them products.
The difference, is not just a marketing slang. It is in the kinds of programs that are available, and the features these programs have. In this series, I will demonstrate my personal encounters with features of Free Software that proprietary software does not provide, and some, I believe can not provide, under its current business model.
But, rather than continuing to describe it, lets just jump to an example that will demonstrate what I am talking about:
Drivers, drivers, drivers…
One of the myths about GNU/Linux and Free operating systems in general, is that they don’t support a lot of hardware.
In plain folks talk “There ain’t no drivers for this thing…”
But reality is, that hardware support in Linux distributions is often better than in the latest version of Microsoft Windows. The myth is propagated by the fact that just about any piece of hardware you buy will have a disk with Windows drivers accompanying it, but no Linux drivers.
People don’t realize this is because such a thing is not needed.
Some time ago, I had a faithful old Pentium 4 2.8GHz computer with a simple graphics card based on Nvidia chip.
There was no driver problem for this card in Windows XP, and it was also recognized out of the box by Ubuntu 7.10, though it had to install the proprietary Nvidia driver to fully support it.
That, was actually less of a hassle than installing the driver for XP from the CD that came with the card, but since Ubuntu 7.10 is significantly newer then Windows XP, it can be forgiven.
One day, the card died (or fried, I am not sure which). Fortunately, I still had the manual for the motherboard, so I knew by the beep sounds my computer made that the fault was in the graphics card and not any other component.
I went to the nearest computer store and got a replacement card. It had the exact same Nvidia chip in it, but the card itself was from a different manufacturer then the old one.
When I plugged it in and booted up, Ubuntu worked as though nothing happened. The Nvidia driver was universal, and it didn’t care that I had a different card in, as long as it had a supported chip in it.
With XP however, the situation was not nearly as good. I had to boot up in “Safe Mode”, uninstall the old driver, then boot up in normal mode and install a different driver for the new card.
Yet another case that demonstrates this issue occurred to me when I bought a very cheap web camera as part of a bet.
The bet was simple: will it be recognized out of the box by Ubuntu? I said “yes” but some people doubted that was possible. Well, I did not have a web cam, and Office Depot were selling some dirt cheap model, so I bought it.
To be fair, I lost the bet. At the time (2008) to get a camera with that particular chip working on Ubuntu a kernel module had to be compiled.
Two years later, however, the module is now part of the official distribution, and the camera is recognized out of the box.
And what of Windows 7? Nothing. since the CD I got with the camera does not contain drivers for it, and since there is no way of identifying the cameras manufacturer (it carries no trademarks), it is useless for Windows user.
Fortunately, I am not a Windows user…
One last case of “driver issues” I keep running in to at work, is with Android devices.
These devices (mostly phones and tablets) use a system called Android Debug Bridge (ADB for short), to communicate with the PC to aid in developing software. Through ADB the developer can debug applications (duh!), read system logs, get shell access to the device and more.
When working on Windows, every individual Android device needs a special driver to be recognized for ADB connection. Even two different phones from the same manufacturer need separate drivers.
This drives a couple of Android developers I know crazy.
On Linux, on the other hand, no driver is necessary. The PC side ADB component can locate any ADB capable device connected to USB and communicate with it.
I do not know what exactly caused the driver architecture to be so drastically different between Windows and Linux. Perhaps it was a purely engineering decision.
But perhaps, it was the fact that much of the hardware support for Linux had to be achieved through reverse engineering due to lack of cooperation from the manufacturers, that brought about modules that support entire families of products and kernel that provides ease of access to peripheral hardware for user-space programs even without a kernel module.
Either way, we have here three small examples where Free Software makes life easy while proprietary software gives you a headache.
Next up: Emergency computer resurrection: a vital solution no proprietary software company could possibly provide.
Stay tuned!
It’s all about trust
We use computers for a lot of things today. In various forms from the desktop to the “Smartphone“.
At work, at home, for business, for pleasure, for education, for communication.
Never before has there been a single object that centered so much of our daily activity around it, intruded in to so many aspects of our life.
Yet, how many people ever stop to think: “Can I trust my computer?”
How many people even consider such a question as making sense? You trust (or don’t trust) people, but things?
Trouble is, we need to be able to trust our computers, not just to work and do what we need of them, but also to keep our secrets from strangers and protect our wealth from theft.
Most people, be they “simple” users who barely understand how to use their computer, or greatest of hackers who know precisely how everything works and how to make it do anything they want, trust their computers implicitly, to varying degrees.
But a computer is a collection of black boxes of two kinds: hardware and software.
They are “black boxes” for two reasons:
1. The people who produce them do their best to hide from us users what they do and how they work.
2. Majority of users don’t posses the knowledge to understand their workings even if they were revealed to them.
Number two is a matter for separate discussion, but as for reason number one: It can and should be avoided!
And this is why I use Free Software and open hardware whenever possible.
This way I can be as certain as possible that my computer (tablet / smartphone / thingamajig) does exactly what it promises and is under my control and not someone else’s.
The skeptics among you will probably say: “You couldn’t possibly read and evaluate every single line of code of every application you use, let alone go over schematics of your hardware.”
And that is true. But, I don’t need to. It is enough for me to know that my phone’s bootloader is not locked or encrypted which means I can update or replace my phone’s OS at any time.
It is enough for me to know that I do not have any “Treacherous computing” features in my PC which could lock me out of my own data at any moment.
Most important, I know my OS and its developers do not, and never will treat me as a thief.
I know this, because the code (and some of the specs) are out in the open. Because they are constantly inspected by thousands of eyes, and because, people and companies that are involved in making these products are interested in making money by providing solutions, rather then just trying to extract it as best they can by providing a product which they continue to control even after you supposedly purchased it.
And, of course, I do not have to rely on this knowledge blindly. When true need arises, I can go and expect the source, or consult people I trust to look in to the guts of the thing and tell me if it’s safe and reliable.
Now, before you recommend that I put on a tin foil hat, consider this growing list of examples where people’s computers betrayed them, at the whim of their true masters:
- Microsoft’s WGA has, on more than one occasion branded hundreds of thousands of lawful customers as thieves and crippled their systems.
- Sony has installed malicious and damaging software on computers of people who bought it’s music CDs.
- Amazon took back two books Kindle users purchased without their permission. Worse still: they took all the notes people made about the books along with them. And, no one even knew they could do it!
- Sony (again!), sold the Play Station 3 with the ability to load another OS. Then took it away without compensation or apology.
- Security expert discovered a back door in Apple ‘s iOS that allows remotely removing applications. Again, phone owners did not know about this “feature”.
- Google put the same kind of “remote delete” feature in it’s “Android Market” application (which, unlike the OS it self is not Free Software or Open Source). It used the feature recently. Though those who read the Market user agreement knew about this capability, and this time it was used to remove malware, there is no guarantee it will not be used for nefarious purposes next time. Google employees have abused their power before, and the company now decided not to release the source for the latest Android version.
And this list can, and probably will keep growing as long as people use closed, proprietery software running on locked devices.
As seen from the last example, even if a large part of your system is Free, as in the case of Android, a single crucial application like the Android Market which is not Free, can take your freedom away.
And next time, it may not be about a book or a feature for geeks, or some music CDs. It may be your life’s work that goes missing, a crucial report for work or school, precious family films or photographs that can not be recreated.
I am glad I found out about about free software before I suffered any such loss.
Free Software is not just about price or ideology or a way for developers to get their hands on some code. It’s about your freedom and security!
I trust the software I use, do you?
Trusted Computing from lafkon on Vimeo.
Welcome back to the 70’s!
Google has finally started a pilot program for netbooks (mini-laptops) running the long awaited (by some) Chrome OS.
Sadly, there aren’t many details about the hardware itself, and the only 3 things we know for sure are:
- It has 12 inch screen
- It has WiFi n and 3G connectivity
- It weighs nearly 2kg! (3.8 pounds which is 1.72kg to be precise)
But there is more to this than just another netbook that strides the border between mini and regular laptops.
Google hails it’s Chrome OS as a new paradigm in computing where “your browser is your OS”. To quote the introduction page: “It runs web-based applications, not legacy PC software.”
To me, this statement is funny, in fact, it appears to be an oxymoron.
I was born in to the PC era. My first computer was 100MHz Pentium 586, and though it still had a turbo button by some archaic standards it might as well have been a “super computer”.
In fact, it was top of the line for home PCs at the time it was purchased.
Technology moved on quickly, so today, you are unlikely to find a smartphone which has a processor slower than 500MHz.
This was the promise of the “Age of the PC”: That any one can get his own computer powerful enough to do whatever the user needed on its own.
Play games, listen to music, watch movies, edit documents – you did not need to rely on anyone.
Most people who are not geeks probably do not know this today, but back before the personal computers hit mass market during the mid 80’s things were very different.
In the 70’s and early 80’s computers were still huge and so expansive that only large organizations such as universities and corporations could own them. To use a computer back then one would use a “terminal” – a dumb screen with a keyboard that connected to the actual computer over some sort of network.
Though several people could use the computer from different terminals at the same time, each user would still get very limited (even by standards of that time) resources allocated to his account.
Each user got certain amount of storage space for his files, certain amount of memory for his programs to use and certain amount of “cpu time” to run his programs.
For nontechnical people reading this (if there are any) think of this as the limits on your email accounts: you can only send attachments of certain size, and you can only keep so much mail in your inbox before it becomes full.
Now imagine that your computer is not really yours: other people are using it, and you have to wait for them to leave enough free resources for you to be able to use it.
This is why personal computers where such a big deal for many people – they could finally use a computer and do what they wanted or needed without “standing in line” or “asking permission” from anyone.
And now, this is the “future” Google is promising us with Chrome OS.
Return from the personal computer to the mainframe and dumb terminal architecture of the 70’s.
Of course, there are are advantages to the “cloud” approach:
- Doesn’t matter where you are: since all of your data and programs you need are “in the cloud” (on some remote Internet server) it does not matter if you have your laptop with you or if you are at your desktop. You can access them from any suitable device as long as it has an Internet connection.
- No maintenance – forget installing software of dealing with viruses: since your computer does virtually nothing except receive and send information to and from the net there’s nothing to do but turn it on.
- Your data is safer – some people will argue that huge corporation like Google or Amazon has better backup facilities than the average computer user, and that their servers are better protected against hackers than your home PC, so you should trust them with all your precious files.
But looking at these supposed benefits, you can see that each of them hides several very real dangers:
- If you can access your files from anywhere, so can anyone who happens to get their hands on your username and password. You may not care if someone gets the photos of your cat, but what about some naughty pictures from your bedroom or your company’s latest financial strategy document?
- No control. When all your data and all the programs you use to manipulate this data are on someone else’s server they are under their control. What if the company you are relying on to provide your cloud computing account suddenly goes out of business? What if they decide not to provide service to your country due to export restrictions, or what if they just lock your account because of a clerical error or because someone decided you violated some terms of use?
Even worse: what if they suddenly change account settings and expose documents you wanted to remain private? This has happed to Facebook users and with Google Buzz.
And what about the applications you use? If they are in the cloud your choice is limited to what your cloud provider gives you. If your provider decides your can only use brand X of document editor, than you will be forced to use only that brand, and if the provider suddenly decides to switch to brand Y? Go with it or change providers (good luck moving all your data and keeping it intact). - Putting all your eggs in one basket. Yes, huge server farms that big corporations own are usually very sturdy. They have UPS, backups, dedicated technicians and all kinds of other goodies, but in the end, even they fail. Yes, even the mighty Google has outages. Also, the bigger the server (or farm) the more attractive target it is for hackers. And that means it will get hit much more and with much bigger force than some Jon Doe’s personal computer.
If something happens to your PC and it stops working you can usually use your laptop, or your work computer or, in worst case scenario barrow your friends computer to finish whatever you need to finish urgently. But with all computing done in the cloud, once the cloud goes down, all computers go down.
To me personally, the lack of control and privacy that comes with cloud computing makes it completely unacceptable as an absolute replacement for the desktop.
There are uses of the cloud that are acceptable to me, and which I believe are unavoidable for an average person:
I trust my personal mail to gmail, because I do not know how to setup and run properly configured email server. Even if I did, I am not sure I would have the time to do a good enough job to keep it properly secure and not fall in to some spammers hands.
I also use Google docs and Picasa for images and documents I need to make publicly available. Since there is no privacy concern here, I don’t mind surrendering them.
And of course, I use worldpress.com for this blog, because I am certainly not about to setup my own installation of world press.
But all these uses are very far from the future Google and some others are planning for us.
With storage devices getting ridiculously huge in capacity and ever smaller in physical size (did you know you can get 32GB of storage on microSD the size of your thumbnail?), and the rest of computer hardware still becoming more powerful and cheaper at the same time, while Internet bandwidth continuing to be limited and expansive (in certain countries much more than in others) I hope most people will think twice before embracing this “futuristic” idea from way back in the 1970’s
My FLOSS
I decided to start this blog with a post introducing all the Free Software projects I’ve published.
It’s not much, but this is the work I am most proud of.
In case you didn’t know, FLOSS (aside from string used to clean teeth) is an acronym for Free Libre Open Source Software.
Now, you might think that it would be simpler and shorter just to say “Free software”, not to mention, a lot less confusing, but this way people tend to think it is just software you can get free of charge.
Even though most people like getting things for free, surprisingly 0$ cost often has negative connotations.
Besides, its not about cost, its about freedom.
For me though, coding these projects was, first and foremost, about learning.
Implementing each feature required learning the use of a new function or a new technique. Some times even a whole new set of development tools.
Also, unlike projects I do as part of my job, these gave me the freedom to experiment – implement what I wanted in the way I wanted without deadlines, demands or the need to waste time on useless trickery in a futile attempt to protect the final product from being copied.
And there was one additional bonus: ego boost. Seeing the download count and getting comments from users directly was pretty nice, especially when those comments were praises and thanks.
LVMTime
This is the first project I’ve ever published. In fact, it went out even before the first commercial app I did as a professional developer hit the market.
It is a “Today screen” plugin for Windows Mobile devices. It displays time and date in various configurations.
This project started out as a way to learn how to write a “Today plugin”.
Since I did not want to do a pointless “Hello world” test, I decided to make it do something useful. At the same time I saw on the forum that people were unhappy with the way date plugin behaved in the then new Windows Mobile 5 OS.
So I made a very simple plugin that just showed date and time on a single line.
I posted it on the forum to see what happens and, to my surprise, it got popular.
So I kept developing it and adding features.
As it turns out, theres a lot more to writing a properly working plugin then MS documentation shows, so along the way I picked up a few tricks that later came in handy on my job.
Two of the neatest (from my perspective) things I’ve done on this project were implementing from scratch a SNTP client to allow synchronizing time from the Internet (just like desktop Windows does) and sticking a small window on the taskbar that looked as though it was an integral part of it.
I actually managed to put the clock display back to where it was in the previous version of the OS, using an outside utility.
At first, I did not think to release the code, though I had no intention to charge money for the software.
I did send it to a couple of people who asked for it because I believed I should share this knowledge as others shared it and allowed me to learn how to write such a plugin.
Later, when I learned about the GNU/GPL and the concept of “Free Software” I properly published the source under GPL v3 license.
Unfortunately, at the time, I was not well familiar with source hosting sites such as SourceForge and Google Code, so I just published the whole thing on the forum I knew.
The down side is, there is no version control and you have to subscribe to the forum to download it.
Some day I might fix it.
For now, the binary version was picked up by a few freeware sites, which added to that ego boost I mentioned earlier:
LVMTime on PocketPCFreeware
LVMTime on FreewarePPC
LVMTime on Softpedia
LVMTopBat
This project, like many other FLOSS projects, began as an attempt to “scratch an itch”.
At the time, I had an i-mate Jamin also know as HTC Prophet.
This was a nice and advanced (for those times) smartphone, but it had a very slow processor (200MHz) and little RAM memory.
I wanted a precise battery meter, but all the ones I could find had a lot of fancy features which were both unnecessary and waste of resources.
Plus, I could not find one that looked exactly the way I wanted, so I just wrote one.
It was interesting to learn how to query and interpret battery status data.
I even managed to use the system notification mechanism to avoid constantly polling for data and wasting CPU cycles.
After making a small modification to make it more general, I put this app on the same forum as LVMTime.
Despite being very simplistic with no configuration options at all, it still had some success – several thousand downloads.
Better still, this was the first time someone took my code and made a derivative application with improvements.
And this is the real power of Free Software: collaborative development and continuous improvement.
Here is one such derivative: iBattery
Though not as popular as LVMTime, LVMTopBat also made it to some freeware sites:
LVMTopBat on PocketPCFreeware
LVMTopBat on Softpedia
Registry Display plugin
Technically speaking this is not a project, but a part of one.
After gathering together tips and tricks for writing a properly functioning “Today plugin” from various sources on the Internet I wanted to put it all together in a skeleton plugin which could later be used as a base for real projects.
At some point, I even thought about writing an article on it for the CodeProject site.
I never gotten around to writing that article, but I did make a basic plugin.
To demonstrate how to properly implement things like user selected text size and refresh handling I decided to let the plugin display a string from the registry.
Mean while, on xda-developers forum there were people looking to add GUI components to MortScript, a simple but powerful scripting language for Windows Mobile which allowed users with no programming knowledge to automate tasks on their devices.
This plugin example turned out to be useful to them.
It is possible to write registry values using MortScript so any script could use my plugin to display information on the today screen.
It wasn’t fancy, but it worked.
Since this project was so basic I released it in to the public domain, which means anyone can use the code in any way for any purpose no string attached.
Though even something this basic falls under todays ridicules copyright laws, I do not believe in copyrighting basic examples of code, not even under the GPL or BSD style licenses.
scr-rotate
This was the firs project I released for GNU/Linux based OS.
Specifically SHR distribution of the OpenMoko project.
It is a graphical application to rotate the screen.
It took me a long while to learn and get used to the different development paradigm of GNU/Linux based environment.
The idea that UI toolkit was something separate from the OS core and that multiple choices were available was a complete novelty.
Programming for Win32 you had one simple API function for creating a window or a button.
Here, you had to choose a widget toolkit and learn its rules.
And before you could do that, you had to familiarize your self with gcc, make and some shell scripting for good masure.
In the end of course, it was well worth it.
And once you do understand the tools and how to use them, you realize that it is the MS way of doing things that is crooked and uncomfortable.
Since the OpenMoko platform was designed specifically for developers to play with, even its most advanced OS is still missing quite a few functions you would find in a commercial phone.
More precisely, the capability is there but the GUI is not.
So it was easy to pick a small feature which I personally was missing and code a fairly simple app to do it.
Once again, this was a learning experience.
And this time, I properly published the sources on a suitable hosting site with open access and version control. There’s even a bug tracking system which I already got to use.
Well, thats all for now.
I hope that in the future, I will have the time to write and release more Free Software projects, maybe even bigger and more useful ones.
For now I do have some bug fixes I want to do on other projects, but as usual 24 hours a day just aren’t enough.
At least, I managed to get this post out.
Thanks for reading.
![[FSF Associate Member]](https://i0.wp.com/static.fsf.org/nosvn/associate/fsf-11332.png)
Lev's developer blog 