Does the word Lego have anything to do with Latin verb lego? When I started learning Latin and learnt the verb "legō" specifically (meaning, "I collect, gather"), I suddenly realized "Oh, so that's where the Lego name comes from!" and it made perfect sense.

It was somewhat surprising for me to learn later that in fact it originates from Danish "leg godt", meaning "play well". I actually still believe Lego has relations with the Latin verb, even though there is no clear proof of it in official sources.

Do you think Latin "legō" has anything to do here, or is it just a mere coincidence?

The official story is that Ole Kirk Kristiansen didn't realise until years after naming the company what it meant in Latin (normally it's said to mean "I put together", not "I collect"), and as there was no construction over the products made in the first many years, it seems unlikely that he should have thought along those lines.

Ole wanted to do "Le godt" but he wanted his name to be short, so he decided to go with the word "Lego" which is a Latin word. Then he realised,  the word he "made up" was a real word.


Why did LEGO create different canister for the Visorak? I have the six original Visorak (Sets 8742, 8743, 8744, 8745, 8746 and 8747) with different canisters (or boxes).

For example, my Suukorak (8747) has a white canister, and my friend's has a black one.

Here's a picture showing the canisters:

Some canisters are colored the same as their lid while others are black.

Why?

I heard a similar question about old cars and how one owner had a hood made of steel and another . . . same make, same model, same year . . . had an aluminum hood. The answer as to why was simple . . . it's the metal the manufacturer had at the time. My guess is once the molding machines are loaded with a color they keep using it until it runs out. Some of the colors were versatile and looked good on multiple sets so they could make more of those before switching colors.

First I want to address tooshel's answer... LEGO doesn't run out of colors. It just doesn't work that way. They craft literal trillions of LEGOs daily, and that's an undershoot. They're cool as far as plastic.

When this kind of thing happens with LEGO, there's usually a backstory. This backstory is usually along the lines of:

Oop! We screwed that up! Quick, redesign, fix it!
(Like the Luke Skywlaker pen.)
What? You think this will look better? OK, make one. Oh wow, that is cool. Let's make the new ones like that.

The second one is much more common than the first nowadays, but the extensive drafting and confirmation processes you see today make certain that neither of these really occur anymore at all.

So. Do you like the black lid, or the white lid? Whichever one you liked, somebody's boss did too. Whichever one you like less, a different boss or perhaps the same with a change of heart, liked as well, enough to release new ones like it.

And as to your sub-question about serial properties... No, they aren't rare enough to carefully re-mark a new model to distinguish it from the old.


How can I remove permanent marker from a LEGO brick? I need to remove permanent marker from hard plastic. How can I do it?

I use pure Eucalyptus oil. It works wonderfully. Keep in mind that if you are using it on LEGO, it will also remove the original printing (but won't harm the plastic itself), so I wouldn't recommend it in that case. But other than that Eucalyptus oil can remove marker, paint, glue-residue, and all kinds of gunk much better and faster than products like Goo-Gone. I'm an artist and use it on a regular basis. Eucalyptus oil is available in small bottles at health-food stores, larger bottles at pharmacies (that's what I use), and also at some Asian stores (usually the cheapest).

Dry erase marker works great but often just rubbing it out with a dry paper towel works also.


How to receive response from direct_command_reply from EV3 using Python? I've established and tested a Bluetooth connection (by playing a tone) between EV3 and Mac running Yosemite with Python 2.7.11.

I used file write as in bt.write(tone) in Python to play the tone with the "tone" variable having the direct command.  Now, I'm trying to read a .rtf text file that is on the brick using Python.

I'm using a direct command for this.  I have created a byte stream for the direct command using opFile (with open_read, read_value and close) all packaged into one direct command (DIRECT_COMMAND_REPLY).

Now, since I'm using Python file write to write this direct command to the Bluetooth serial port, how do I get the value returned (the text value in the .rtf file) by the direct command?

Python file write does not have a return value. Please help on how I can get the reply from the direct command with Python.

Reading files is better done by system commands. Here is a class EV3, that sends direct commands and system commands. The program sends a direct command (does nothing) and uses the system commands BEGIN_UPLOAD and CONTINUE_UPLOAD to read file /bin/usb-devices from the EV3 device:

#!/usr/bin/env python3

import socket
import struct
import time

class EV3():
    def __init__(self, host: str):
        self._sock = socket.socket(
            socket.AF_BLUETOOTH,
            socket.SOCK_STREAM,
            socket.BTPROTO_RFCOMM
        )
        self._sock.connect((host, 1))

    def __del__(self):
        self._sock.close()

    def send_direct_cmd(self, ops: bytes, local_mem: int=0, global_mem: int=0) -> bytes:
        dir_cmd = b''.join([
            struct.pack('<h', len(ops) + 5),
            struct.pack('<h', 42),
            DIRECT_COMMAND_REPLY,
            struct.pack('<h', local_mem*1024 + global_mem),
            ops
        ])
        self._sock.send(dir_cmd)
        self.printHex('Sent', dir_cmd)
        reply = self._sock.recv(5 + global_mem)
        self.printHex('Recv', reply)
        return reply

    def send_system_cmd(self, cmd: bytes) -> bytes:
        sys_cmd = b''.join([
            struct.pack('<h', len(cmd) + 3),
            struct.pack('<h', 42),
            SYSTEM_COMMAND_REPLY,
            cmd
        ])
        self._sock.send(sys_cmd)
        self.printHex('Sent', sys_cmd)
        time.sleep(0.1)
        return self._sock.recv(1024)

    def printHex (self, desc: str, hex: bytes) -> None:
        """Print a hex-String in human readable form"""
        print(desc + ' 0x|' + ':'.join('{:02X}'.format(byte) for byte in hex) + '|')

DIRECT_COMMAND_REPLY = b'\x00'
SYSTEM_COMMAND_REPLY = b'\x01'
opNop                = b'\x01'
BEGIN_UPLOAD = b'\x94'
CONTINUE_UPLOAD = b'\x95'

# direct command
my_ev3 = EV3('00:16:53:42:2B:99')
ops = opNop
my_ev3.send_direct_cmd(ops)

# system commands
path = '/bin/usb-devices'
cmd = b''.join([
    BEGIN_UPLOAD,
    struct.pack('<H', 1012),      # SIZE
    str.encode(path) + b'\x00'    # NAME
])
reply = my_ev3.send_system_cmd(cmd)
(size, handle) = struct.unpack('<IB', reply[7:12])
part_size = min(1012, size)
fmt = str(part_size) + 's'
data = struct.unpack(fmt, reply[12:])[0]
rest = size - part_size
while rest > 0:
    part_size = min(1016, rest)
    cmd = b''.join([
        CONTINUE_UPLOAD,
        struct.pack('<BH', handle, part_size)
    ])
    reply = my_ev3.send_system_cmd(cmd)
    fmt = 'B' + str(part_size) + 's'
    (handle, part) = struct.unpack(fmt, reply[7:])
    data += part
    rest -= part_size
print(data.decode("utf8"))

You find additional details in
Lesson 11. Or look in github. I hope, this helps!