Junk Hunt - Strange Typewriter Thing

I'm on the hunt for information, or even the actual thing... What thing?... Well, in the early 1990's my parents took me into a stationary store in Nottingham, I think it was Staples or Office World near the Post Office main buildings, so we're talking St Anns or City Centre ish, certainly behind the Victoria Centre.

Anyway, in there I saw a machine I was sorely tempted to get, it was a semi-electronic typewriter, so it had a form factor about 11" a typewriter keyboard with an LCD screen across the center, you typed could see the text then when you hit enter it write it to the typewriter as a nearly silent printed line...

It also simultaneously write this as an ASCII text file onto a 3.5" floppy which was inserted into the right hand side.

The one I saw was red, cherry red.

The print was a very strong, black, the ribbon was a one use thing once it had put a letter down if you came over the same piece of ribbon (by winding it back) and put another character it'd be missing the bits from the mask cut by writing the prior letter.

And... I loved it.....

I went to see this thing about six times.  I really wanted it to augment my then A-Level studies.  because it was silent, the keyboard had a tactile feel, but no click, the printing was this nearly silent swish and you got the text file from it... or you could put a text file into the disk, load it and it'd print the whole thing out in this lovely type.

Remember, at home I was toting a 9 pin Citizen 120D+ printer, so this really vibrant printing really appealed to me to present things.

If you have any idea what device I'm talking about, comment below!

Comments

Post a Comment

Popular posts from this blog

C++ : Ignored qualifiers (-Wignored-qualifiers)

What is an ignored qualifier?  Well, in a class, lets have a student class: #include <string> class Student {     public:         const std::string Name;     private:         bool m_Present;     public:         Student(const std::string& p_Name)             :             Name(p_Name),             m_Present         {         }                 void SetPresent() { m_Present = true; }         void SetAbsent() { m_Present = false; } }; Now, we may want to access the present flag, therefore provide a function to do so:     bool Present() const { return m_Present } This function is telling the user of our class quite a bit, it tells them that the return type is boolean and that the calling of this function makes no changes to the class  contents (const trailing the parameter list). However, for me, this isn't quite right, I believe that we want to inform any user that the boolean returned is also constant, it does not change unless you alter the internal value with the "Set
Read more

C++: The Dilemma of using Exceptions

Image
As a C++ developer I've recently been in the midst of the Exceptions debate.  Exceptions as a feature of the C++ language have long divided the community, naively I've often put this down to their coming to the language from elsewhere (C perhaps) where exceptions were not the norm. This was a mistake, for in the projects I've previously worked upon the overhead of an exception compared to the ramifications of the error resulting in a crash have often totally outweighed the overhead, making deciding to employ an exception exceptionally easy (*bum bum*).  Exceptions were the norm, still are and should be to you too (according to the C++ Core Guidelines https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#Ri-except ). The difficulty, the dilemma if you will, comes not from the feature, but the cost.  If you application domain demands high performance you can not risk using exceptions, the argument carries on therefore whether in not using them to avoid
Read more

Development : Anti-Hungarian Notation

Whilst cutting code I employ a coding style, which I enforce, whereby I output the scope of the variable being used with a prefix. "l_" for Local "m_" for Member "c_" for constant "e_" for enum And so forth, for static, parameter and a couple of others.  I also allow compounds of these, so a static constant would be: "sc_" This is useful in many languages, and imperative in those which are not type strict, such as Python. Some confuse this with "Hungarian Notation", it's not.  Hungarian notation is the practice of prefixing a type notification to the variable name, for example "an integer called count" might be "iCount". I have several problems with anyone using Hungarian Notation, and argue against it thus. With modern code completion and IDE lookup tools this is really not needed, with useful and meaningful naming of your variables the type is not needed and finally there are multiple types with the s
Read more