April, 2011 – The Month The Desktop Changes

CompuLab/Trim Slice plans to ship a desktop PC that fits in your hand with Ubuntu GNU/Linux.

$250 – $350 retail Wholesale less than $200

It comes in two models, one with a 2.5 inch hard drive and one thinner model with SSD. This could be the first pure ARM desktop machine, just what I predicted and that some readers don’t believe will happen. This gadget should have immediate attractiveness for software developers including kernel developers and it will sooner or later have lots of apps from both Ubuntu (or other distros) and Android.

The thing is crammed with connectors: 4 USB, 1 HDMI, 1 DVI, microSD, audio in/out, etc. It’s all there.

Despite my being out of work, 2011 is shaping up to be a great year. This could be the ARMed gadget for me. It’s not a phone nor a tablet… It even has a wireless connector.

Links:

About Robert Pogson

I am a retired teacher in Canada. I taught in the subject areas where I have worked for almost forty years: maths, physics, chemistry and computers. I love hunting, fishing, picking berries and mushrooms, too.
This entry was posted in technology. Bookmark the permalink.

14 Responses to April, 2011 – The Month The Desktop Changes

  1. twitter says:

    Oh please, OldMan, I’ve done it both ways and Microsoft sucks life. Microsoft spreadsheet are about the least reliable, most expensive way to do any kind of work. The spreadsheet itself is famous for math errors, and complicated scripts in them are almost impossible to debug. Microsoft breaks VB and VBS with a frequency that drove sane people away more than ten years ago. Please, please, please don’t let anyone use their broken database which fails to clean out temporary tables and bloats even when used for simple flat tables. People who absolutely must have an Office like answer should use Open Office which works as advertised. Everyone else should have someone like Pogson develop a few scripts that will do the job. The Unix way involves a little more study, but not much, and is far more robust, cost effective and professional looking. The end result, of course, can be rolled up into web pages, Open Office or Latex if you want to do things right. Even Microsoft uses Macs to format their sales literature.

    Thanks for the pointer to a great desktop, Pogson. These are quite promising. I too expect these things to be widely adopted. PC prices are quickly going the way pocket calculators went.

  2. oldman says:

    “It looks to me like you did $150 worth of work and paid M$ $50 for the trouble…”

    The point is Pog, that I would have easily done $600.00 worth of work on this project alone to make up for the so called zero $ solution that you propose.

    When you add up the productivity costs to make up for the shortcomings of most of the solutions that you would propose, the cost IMHO is way beyond the $50.00

    And in the end with all due respect, its MY valuing of my time that counts, not yours.

  3. It looks to me like you did $150 worth of work and paid M$ $50 for the trouble…

  4. oldman says:

    “A free market is supposed to be where a willing customer comes together with a willing seller to make a deal. What’s with this idea that the seller gets to dictate what the consumer buys?”

    Where do you get the idea that a customer can dictate what a business is willing to sell. If you dont like what a vendor is selling, find another vendor. If it turns out that no vendor is willing or interested in selling you what you want, then thats just something that you get to deal with. IN this case, you have a vendor who will sell you a quite capable single board computer with an ARM processor. If you really want to have and ARM based system, you can buy the system and roll your own using the ARM based Debian distro, then you can recompile all your software that you need adjusting the source code as needed.

    That doesnt sound too hard, does it, Pog?

    “A business could very well determine that ARM will be their platform for IT for all kinds of good technical reasons and then fills in the software requirements. ”

    Any business that cares about platforms is going to choose one that is supported by main stream vendors. If they should want RISC based systems, they have their choice of Oracle/Sun Sparc and IBM Power 7. ARM isnt even in the picture.

    “A large business can write its own software if necessary. Using FLOSS components it’s very easy. The world is much larger than any business and can write all the software it needs.”

    Large businesses do write their own software already, Pog . Some of them do it with purely commercial tools, others customize FOSS, or commercialized FOSS. What I can tell you however is that very few of those businesses build anything from scratch – its simply too much work for most companies. Most purchase commercial off the shelf business software and customize it to their needs. That effort in itself can be a huge one, and the customizations become critical to the business.

    “I once worked in a large hospital that had the world’s worst control system for a nuclear facility. I studied the source code and determined that six person-years of effort had gone into it. I rewrote the whole thing in six weeks using FLOSS, back when I did not even know what FLOSS was. All I had to do was to write the expert decision making of a skilled operator and provide the user with necessary feedback. “No” was all the original programme provided in assembler. Training time for operators dropped from six months to one month because the control system actually taught operators what they needed to learn. FLOSS does work.”

    I’m sorry Pog, but anyone could have improved on a system like this no matter what tools they used. I myself took a mainframe based Utility costing program, moved it to the PC, and adapted the interface for interactive use. The resulting program was 100% easier to work with and portable to boot. I did this with commercial software and compiled the results.

  5. oldman says:

    “I look at long-term costs, not just short-term.”

    I look as well. and my time is worth more to me in the long term than the short term.

    The costs for continued use of MS office over the 20+ years that I have been using amount to less than $50.00 per year. At my current rate of billable that is about 15 minutes of my time per year. The cost in my time to have to continually make up for the shortcomings of the piece of FOSS that you would propose as a substitute would quickly and easily exceed the cost of investing in the package that automated the steps very quickly.

    Like yourself I also do a lot of one off projects. One of them involved a powershell script that extracted information from our VMWare based virtual infrastructure(using vendor supplied powershell extensions) and then use the COM object interface to MS excel to feed the resulting information directly into a multi-tab spreadsheet. Here it is:

    #
    # Script to list out general stats for all VM’s in a virtual center
    # Including Name, Power state, Current Host, total memory CPU and disk space occupied

    ### Variables

    $vc_server = “,.” # Your Virtual Center
    $vm_data = “” # Temporary Variable to store VM info
    $Total_size = 0 # Temporary counter for total VM storage
    $intRow = 2 # Row counter sheet 1
    $intRow2 = 2 # Row counter sheet 2
    $intRow3 = 2 # Row Counter Sheet 3
    $Array_length = 0 # array Length

    # Summary Statistics
    #
    $VMCount = 0
    $DatastoreCount = 0
    $VMMemory = 0
    $VMCPU = 0
    $VMStorage = 0
    #
    #
    #
    #
    #

    ### Establish connection to Virtual Center

    echo “Connecting to vCenter Instance…” | Out-Host
    echo “” | Out-Host

    $foo = Connect-VIServer $vc_server

    echo “” | Out-Host

    # create an excel spreadsheet using a COM
    $Excel = New-Object -Com Excel.Application
    $Excel.visible = $True
    $Excel = $Excel.Workbooks.Add() # Add workbook with first 3 sheets…
    $Excel.worksheets.item(1).Name = “Summary” # and…
    $Excel.worksheets.item(2).Name = “VM Stats” # name…
    $Excel.worksheets.item(3).Name = “VMDK Stats” # each
    $foo = $Excel.Worksheets.add() # Add 4th worksheet…
    $Excel.Worksheets.item(1).Name = “Datastore Stats” # and name it

    # Get Data from VC and sort by VM Name

    echo “Getting VM Information and Sorting…” | Out-Host
    $vm_data = Get-VM | Sort host
    echo “Data retrieval complete.” | Out-Host
    echo “” | Out-Host

    # get references to the worksheets we will be working with

    $Summary = $Excel.WorkSheets.Item(“Summary”) # Get reference to worksheet 1
    $Sheet = $Excel.WorkSheets.Item(“VM Stats”) # Get reference to worksheet 2
    $Sheet2 = $Excel.WorkSheets.Item(“VMDK Stats”) #Get reference to worksheet 3
    $Sheet3 = $Excel.WorkSheets.Item(“Datastore Stats”) #Get reference to worksheet 4

    # Set up column Headers for all three sheets

    $now = get-date

    $Summary.Cells.Item(1,1) = “Production Virtual Infrastructure Summary as of $now”
    $Summary.Cells.Item(1,1).Font.Bold = $True
    $Summary.Cells.Item(1,1).Font.Name = “Calibri”
    $Summary.Cells.Item(1,1).Font.Size = 14
    $Summary.Cells.Item(3,1) = “Total Number of Virtual Machines”
    $Summary.Cells.Item(4,1) = “Total VCPU’s”
    $Summary.Cells.Item(5,1) = “Total Memory Resources (Mb)”
    $Summary.Cells.Item(6,1) = “Total Storage Occupied by Virtual Machines (Gb)”

    $Summary.Cells.Item(3,1).Font.Bold = $true
    $Summary.Cells.Item(4,1).Font.Bold = $true
    $Summary.Cells.Item(5,1).Font.Bold = $true
    $Summary.Cells.Item(6,1).Font.Bold = $true

    $Sheet.Cells.Item(1,1) = “VM Summary Information as of $now”
    $Sheet.Cells.Item(1,1).Font.Bold = $True
    $Sheet.Cells.Item(1,1).Font.Name = “Calibri”
    $Sheet.Cells.Item(1,1).Font.Size = 14

    $Sheet2.Cells.Item(1,1) = “VM VMDK File Information as of $now”
    $Sheet2.Cells.Item(1,1).Font.Bold = $True
    $Sheet2.Cells.Item(1,1).Font.Name = “Calibri”
    $Sheet2.Cells.Item(1,1).Font.Size = 14

    $Sheet3.Cells.Item(1,1) = “Datastore Statistics as of $now”
    $Sheet3.Cells.Item(1,1).Font.Bold = $True
    $Sheet3.Cells.Item(1,1).Font.Name = “Calibri”
    $Sheet3.Cells.Item(1,1).Font.Size = 14

    $Sheet.Cells.Item($intRow,1) = “VM Name”
    $Sheet.Cells.Item($intRow,2) = “Current Host”
    $Sheet.Cells.Item($intRow,3) = “Power State”
    $Sheet.Cells.Item($intRow,4) = “Number of CPU’s”
    $Sheet.Cells.Item($intRow,5) = “Memory(Mb)”
    $Sheet.Cells.Item($intRow,6) = “Total Space(Gb)”
    $Sheet.Cells.Item($intRow,7) = “Description”

    $Sheet2.Cells.Item($intRow2,1) = “VM name”
    $Sheet2.Cells.Item($intRow2,3) = “Size(Gb)”
    $Sheet2.Cells.Item($intRow2,2) = “Current Path”

    $Sheet3.Cells.Item($intRow2,1) = “name”
    $Sheet3.Cells.Item($intRow2,2) = “ID”
    $Sheet3.Cells.Item($intRow2,3) = “Type”
    $Sheet3.Cells.Item($intRow2,4) = “Capacity(Gb)”
    $Sheet3.Cells.Item($intRow2,5) = “Free Space(Gb)”
    $Sheet3.Cells.Item($intRow2,6) = “% Free”

    echo “Reporting out VM Statistics…” | Out-Host

    foreach ($i in 1..7) {
    $WorkBook = $Sheet.Cells.Item($intRow,$i)
    $WorkBook.Interior.ColorIndex = 10
    $WorkBook.Font.ColorIndex = 11
    $WorkBook.Font.Bold = $True
    $WorkBook.Font.Name = “Calibri”
    $WorkBook.Font.Size = 12
    }

    foreach ($i in 1..6) {
    $WorkBook = $Sheet2.Cells.Item($intRow2,$i)
    $WorkBook.Interior.ColorIndex = 10
    $WorkBook.Font.ColorIndex = 11
    $WorkBook.Font.Bold = $True
    $WorkBook.Font.Name = “Calibri”
    $WorkBook.Font.Size = 12
    }
    foreach ($i in 1..6) {
    $WorkBook = $Sheet2.Cells.Item($intRow3,$i)
    $WorkBook.Interior.ColorIndex = 10
    $WorkBook.Font.ColorIndex = 11
    $WorkBook.Font.Bold = $True
    $WorkBook.Font.Name = “Calibri”
    $WorkBook.Font.Size = 12
    }

    foreach ($i in 1..6) {
    $WorkBook = $Sheet3.Cells.Item($intRow3,$i)
    $WorkBook.Interior.ColorIndex = 10
    $WorkBook.Font.ColorIndex = 11
    $WorkBook.Font.Bold = $True
    $WorkBook.Font.Name = “Calibri”
    $WorkBook.Font.Size = 12
    }

    $intRow++ # move to first data row in sheet 1
    $intRow2++ # move to first data row in sheet 2
    $intRow3++ # move to first data row in sheet 3

    # Process VM information into spreadsheet

    $Array_length = $vm_data.Length -1
    $VMCount = $vm_data.Length

    foreach ($z in 0..$Array_length) {
    $Sheet.Cells.Item($intRow,1) = $vm_data.SyncRoot[$z].Name # Get the VM’s Name
    $Sheet.Cells.Item($intRow,2) = $vm_data.SyncRoot[$z].host.name # get the host that they are on
    $state = $vm_data.SyncRoot[$z].powerstate # get the power state

    if ($state -eq 1){
    $Sheet.Cells.Item($intRow,3) = “Powered On”
    }
    else
    {
    $Sheet.Cells.Item($intRow,3) = “Powered Off”
    }
    $cpu = $vm_data.SyncRoot[$z].numcpu # get the number of cpu’s
    $VMCPU += $cpu
    $Sheet.Cells.Item($intRow,4) = $cpu
    $mem = $vm_data.SyncRoot[$z].memorymb # get the memory
    $VMmemory += $mem
    $Sheet.Cells.Item($intRow,5) = $mem

    #
    # N.B. we have to referr to the synchronized root of the vmdk collection. Apparently
    # “has” to be kept synchronized.

    $hd = $vm_data.SyncRoot[$z].Harddisks # get vmdk collection
    $hd_arrlen = $hd.length – 1 # calculate index of last disk

    # then we process the entire array

    foreach ($y in 0..$hd_arrlen) {

    $Sheet2.Cells.Item($intRow2,1) = $vm_data.SyncRoot[$z].Name # Get the VM’s Name
    $Sheet2.Cells.Item($intRow2,3) = $hd[$y].capacitykb / 1048576 # Get the VMdk capacity
    $Sheet2.Cells.Item($intRow2,2) = $hd[$y].filename # Get the path to teh vmdk
    $Total_size = $Total_size + $hd[$y].capacitykb / 1048576 # Increment total storage
    $intRow2++ # Increment Row
    }

    $Sheet.Cells.Item($intRow,6) = $Total_size # Output sum of vmdk sizes for vm
    $Sheet.Cells.Item($intRow,7) = $vm_data.SyncRoot[$z].Description # Get the VM’s Description if presents
    $vmg = Get-VMGuest $vm_data.SyncRoot[$z].Name #set up to get IPaddress
    $Sheet.Cells.Item($intRow,8) = $vmg.ipaddress # enter ip address

    $intRow++ # Increment Row
    $VMStorage += $Total_size
    $Total_size = 0 # Reset Total Counter
    }
    echo ” Complete.” | Out-Host
    echo “” | Out-Host

    $Summary.Cells.Item(3,2) = $VMCount
    $Summary.Cells.Item(4,2) = $VMCPU
    $Summary.Cells.Item(5,2) = $VMMemory
    $Summary.Cells.Item(6,2) = $VMStorage

    $ds_data = Get-Datastore
    $ds_length = $ds_data.Length -1

    foreach ($z in 0..$ds_length) {

    $Sheet3.Cells.Item($intRow3,1) = $ds_data.SyncRoot[$z].Name # Get the VM’s Name
    $Sheet3.Cells.Item($intRow3,2) = $ds_data.SyncRoot[$z].ID # get the host that they are on
    $Sheet3.Cells.Item($intRow3,3) = $ds_data.SyncRoot[$z].Type # get the number of cpu’s
    $Sheet3.Cells.Item($intRow3,4) = $ds_data.SyncRoot[$z].capacitymb # get the memory
    $Sheet3.Cells.Item($intRow3,5) = $ds_data.SyncRoot[$z].freespacemb # get the memory
    $Sheet3.Cells.Item($intRow3,6) = ($ds_data.SyncRoot[$z].freespacemb / $ds_data.SyncRoot[$z].capacitymb) * 100
    $intRow3++ # Increment Row

    }

    ###ADJUSTS COLUMN WIDTH FOR SHEET AUTOMATICALLY
    $WorkBook = $Summary.UsedRange
    $WorkBook.EntireColumn.AutoFit()
    $WorkBook = $Sheet.UsedRange
    $WorkBook.EntireColumn.AutoFit()
    $WorkBook = $Sheet2.UsedRange
    $WorkBook.EntireColumn.AutoFit()
    $WorkBook = $Sheet3.UsedRange
    $WorkBook.EntireColumn.AutoFit()

    The result was ready for presentation to management. This script debugged and built in about a day’s worth of time thanks to features built in to Office that leveraged services of the windows platform. I even had had free GUI based debugging tools made by another vendor for powershell that that allowed me to quickly get to the root of problems. All of this for what amounts to $50.00 per year.

    IMHO well worth the money.

  6. What’s the difference between massaging data or creating software to massage the data once and paying licensing fees on commercial software forever to do the same thing? Infinity. I look at long-term costs, not just short-term. As well, I do a lot of one-off projects. Even though a commercial product exists, I can often complete my project before the paperwork on a purchase could be completed. For example, at Easterville, I included FLOSS library management software in the package. A consultant persuaded my employer to go for commercial stuff. It took them a month of meetings to decide and weeks to install the non-free software. Just getting the authentication code to work was a nightmare. The software I provided was already in operation for about 15 minutes of my time…

  7. oldman says:

    “There are all kinds of alternatives scripts, languages and writing tools available on GNU/Linux systems for doing the same things.”

    I seem to recall one of those alternate tools that you proposed for replacing the built in functionality in MS Excel 2007 to derive a schema from XML data on file open. It was a command line utility, to derive a schema from XML data but the utility had some limitation in what could be presented in the data stream. THis means that it would have required additional pre processing just to prepare the xml data for input to your solution. All of this would be extra work Pog. It would be wasted time, wasted effort IMHO, and all for nothing more than to avoid having to spend money on a commercial product.

    Many of your so called alternative solutions are like this.

    Do you really believe proposing alternatives like this is really going to fly, especially for those familiar with the commercial alternatives?

  8. There are lots of users who require only a few readily available applications like browser, e-mail client, text messaging client etc. No OS has a monopoly on utilities.

    A free market is supposed to be where a willing customer comes together with a willing seller to make a deal. What’s with this idea that the seller gets to dictate what the consumer buys? A business could very well determine that ARM will be their platform for IT for all kinds of good technical reasons and then fills in the software requirements. A large business can write its own software if necessary. Using FLOSS components it’s very easy. The world is much larger than any business and can write all the software it needs.

    I once worked in a large hospital that had the world’s worst control system for a nuclear facility. I studied the source code and determined that six person-years of effort had gone into it. I rewrote the whole thing in six weeks using FLOSS, back when I did not even know what FLOSS was. All I had to do was to write the expert decision making of a skilled operator and provide the user with necessary feedback. “No” was all the original programme provided in assembler. Training time for operators dropped from six months to one month because the control system actually taught operators what they needed to learn. FLOSS does work.

  9. oldman says:

    Hardware that can’t run the applications that its users require is IMHO ultimately useless.

  10. John Kerr says:

    It runs on very low power and consumed a much lower amount of power and material to manufacture when compared to the traditional desktop. It consumes less packaging to ship as well.

    In a world where every kilowatt counts, this is this is the kind of hardware that we need.

  11. The folks who are “knowledge workers” who write vb scripts are a small minority of users of IT. There are all kinds of alternatives scripts, languages and writing tools available on GNU/Linux systems for doing the same things. People may have painted themselves into a corner but it is still worthwhile to fix that. Munich is an example. It took them years to replace all their templates for OpenOffic.org but it was worth it because now they have a much lower cost of IT going forward and a much greater confidence that they control their destiny.

  12. oldman says:

    “. I have never met a person who needed a particular browser or word-processor to do their work.”

    Then with all due respect, you haven’t met very many people. Where I work, over and above the requirements of those enterprise applications, I regularly work with knowledge workers who regularly leverage macros and are writing small vbscript applications. very many people work with microsoft access for organizing inormation, and the number of home grown applications that I see every day are larger than one would think.

    “Some do feel they need a particular OS.”

    When you have requirements that are only met by applications running on a particular OS, its more than a feeling, its a requirement.

  13. Some do. Some don’t. I have never met a person who needed a particular browser or word-processor to do their work. Some do feel they need a particular OS.

  14. oldman says:

    Pog:

    Perhaps you need to take a look at the compulab site itself at http://www.compulab.co.il/index.htm

    THis is just one of the many companies that specializes in embedded systems and single board computers that can be used by software engineers to develop software development for embedded systems.

    I doubt this particular vendor represents the future Pog. At most they will create platforms for software development and testing.

    People run specific applications, not operating systems.

Leave a Reply

Your email address will not be published. Required fields are marked *